diff --git a/src/napari_deeplabcut/_tests/core/layer_manager/test_manager.py b/src/napari_deeplabcut/_tests/core/layer_manager/test_manager.py
index 5bc07b6d..45bf590f 100644
--- a/src/napari_deeplabcut/_tests/core/layer_manager/test_manager.py
+++ b/src/napari_deeplabcut/_tests/core/layer_manager/test_manager.py
@@ -8,13 +8,14 @@
 import pytest
 from napari.layers import Image, Points
 
-from napari_deeplabcut.config.models import AnnotationKind
+from napari_deeplabcut.config.models import AnnotationKind, ImageMetadata
 from napari_deeplabcut.core.layer_lifecycle import LayerLifecycleManager
 from napari_deeplabcut.core.layer_lifecycle.display_settings import (
     MACHINE_LABELS_POINTS_DISPLAY,
     PointsDisplaySource,
 )
 from napari_deeplabcut.core.layer_lifecycle.manager import PointsRuntimeResources
+from napari_deeplabcut.core.project_paths import is_same_dataset
 from napari_deeplabcut.tracking.core.data import build_tracking_result_metadata
 
 
@@ -105,6 +106,7 @@ def connect_signal_recorders(manager):
         inserted=SignalRecorder(),
         removed=SignalRecorder(),
         conflicts=SignalRecorder(),
+        dataset_mismatch=SignalRecorder(),
     )
 
     manager.refresh_video_panel_requested.connect(rec.refresh_video)
@@ -119,6 +121,7 @@ def connect_signal_recorders(manager):
     manager.layer_insert_processed.connect(rec.inserted)
     manager.layer_remove_processed.connect(rec.removed)
     manager.session_conflict_rejected.connect(rec.conflicts)
+    manager.layer_dataset_mismatch.connect(rec.dataset_mismatch)
     return rec
 
 
@@ -702,3 +705,590 @@ def attach(store, controls, resources):
 
     for key in ("M", "F"):
         assert keymap[key].__self__ is second_controls, f"{key} still bound to the previous controls"
+
+
+# ---------------------------------------------------------------------------
+# _remap_frame_indices
+# ---------------------------------------------------------------------------
+NO_DATASET_FOLDER = object()
+
+
+def _points_bound_to(paths, *, root, dataset_folder=None):
+    """A Points layer as the readers build one: paths, root, and an immutable identity."""
+    layer = make_nonempty_points("bound")
+    if dataset_folder is None:
+        key = root
+    elif dataset_folder is NO_DATASET_FOLDER:
+        key = None
+    else:
+        key = dataset_folder
+    layer.metadata = {
+        "paths": list(paths),
+        "root": root,
+        "dataset_folder": key,
+    }
+    return layer
+
+
+def _manager_showing(layer, *, paths, root, dataset_folder=None):
+    """A manager whose image context is the given folder."""
+    manager = LayerLifecycleManager(viewer=DummyViewer([layer]))
+    manager._image_meta = ImageMetadata(paths=list(paths), root=root)
+    manager._image_dataset_folder = root if dataset_folder is None else dataset_folder
+    return manager
+
+
+def test_remap_frame_indices_refuses_a_layer_from_another_dataset(monkeypatch):
+    """Identity is decided by dataset_folder, whatever the frame names happen to be.
+
+    These two folders share every frame name, which is the DLC norm rather than evidence
+    that they hold the same footage.
+    """
+    old_paths = ["labeled-data/videoA/img000.png", "labeled-data/videoA/img001.png"]
+    layer = _points_bound_to(old_paths, root="C:/project/labeled-data/videoA")
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/videoB/img000.png", "labeled-data/videoB/img001.png"],
+        root="C:/project/labeled-data/videoB",
+    )
+
+    warned = []
+    monkeypatch.setattr(manager, "_report_layer_left_on_previous_dataset", lambda ly: warned.append(ly))
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.metadata["paths"] == old_paths
+    assert layer.metadata["root"] == "C:/project/labeled-data/videoA"
+    assert warned == [layer]
+
+
+def test_remap_frame_indices_refuses_another_project_with_the_same_video_name(monkeypatch):
+    """The keys are absolute, so two projects holding `labeled-data/mouse1` stay distinct."""
+    old_paths = ["labeled-data/mouse1/img000.png"]
+    layer = _points_bound_to(old_paths, root="C:/project-A/labeled-data/mouse1")
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/mouse1/img000.png"],
+        root="C:/project-B/labeled-data/mouse1",
+    )
+
+    warned = []
+    monkeypatch.setattr(manager, "_report_layer_left_on_previous_dataset", lambda ly: warned.append(ly))
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.metadata["root"] == "C:/project-A/labeled-data/mouse1"
+    assert warned == [layer]
+
+
+def test_remap_frame_indices_leaves_metadata_alone_when_nothing_maps(monkeypatch):
+    """Same dataset, but no frame overlap: adopt neither root nor paths."""
+    old_paths = ["labeled-data/videoA/imgA000.png"]
+    layer = _points_bound_to(old_paths, root="C:/project/labeled-data/videoA")
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/videoA/renamed000.png"],
+        root="C:/project/labeled-data/videoA",
+    )
+
+    warned = []
+    monkeypatch.setattr(manager, "_report_layer_left_on_previous_dataset", lambda ly: warned.append(ly))
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.metadata["paths"] == old_paths
+    assert layer.metadata["root"] == "C:/project/labeled-data/videoA"
+    assert warned == [layer]
+
+
+def test_remap_frame_indices_adopts_root_and_paths_together_when_frames_map():
+    """The project moved: same dataset, new prefix, so both fields follow."""
+    new_paths = ["labeled-data/videoA/imgA000.png"]
+    layer = _points_bound_to(
+        ["old/labeled-data/videoA/imgA000.png"],
+        root="D:/moved/labeled-data/videoA",
+        dataset_folder="C:/project/labeled-data/videoA",
+    )
+
+    manager = _manager_showing(layer, paths=new_paths, root="C:/project/labeled-data/videoA")
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.metadata["paths"] == new_paths
+    assert layer.metadata["root"] == "C:/project/labeled-data/videoA"
+
+
+def test_remap_frame_indices_adopts_an_unbound_layer():
+    """A config placeholder has no dataset of its own, so it takes whatever is open."""
+    new_paths = ["labeled-data/videoA/img000.png"]
+    layer = make_points("placeholder")
+    layer.metadata = {"project": "C:/project"}
+
+    manager = _manager_showing(layer, paths=new_paths, root="C:/project/labeled-data/videoA")
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.metadata["root"] == "C:/project/labeled-data/videoA"
+
+
+def test_dataset_mismatch_is_reported_once_per_target_folder(qtbot):
+    """The remap sweep revisits every layer per insert, so repeats must be suppressed."""
+    layer = _points_bound_to(["labeled-data/videoA/imgA000.png"], root="C:/project/labeled-data/videoA")
+
+    manager = LayerLifecycleManager(viewer=DummyViewer([layer]))
+    rec = connect_signal_recorders(manager)
+    manager._image_meta = ImageMetadata(
+        paths=["labeled-data/videoB/imgB000.png"],
+        root="C:/project/labeled-data/videoB",
+    )
+
+    manager._remap_frame_indices(layer)
+    manager._remap_frame_indices(layer)
+
+    assert rec.dataset_mismatch.count == 1
+    assert "videoA" in rec.dataset_mismatch.calls[0][0]
+
+    # A different folder is a new fact, so it is reported again.
+    manager._image_meta = ImageMetadata(
+        paths=["labeled-data/videoC/imgC000.png"],
+        root="C:/project/labeled-data/videoC",
+    )
+    manager._remap_frame_indices(layer)
+
+    assert rec.dataset_mismatch.count == 2
+
+    # Going back to a folder already reported is not a new fact.
+    manager._image_meta = ImageMetadata(
+        paths=["labeled-data/videoB/imgB000.png"],
+        root="C:/project/labeled-data/videoB",
+    )
+    manager._remap_frame_indices(layer)
+
+    assert rec.dataset_mismatch.count == 2
+
+
+def test_dataset_mismatch_names_both_folders_in_full(qtbot):
+    """Two projects can hold a dataset of the same name, so bare names do not identify it."""
+    layer = _points_bound_to(
+        ["labeled-data/mouse1/img000.png"],
+        root="C:/project-A/labeled-data/mouse1",
+    )
+
+    manager = LayerLifecycleManager(viewer=DummyViewer([layer]))
+    rec = connect_signal_recorders(manager)
+    manager._image_meta = ImageMetadata(
+        paths=["labeled-data/mouse1/img000.png"],
+        root="C:/project-B/labeled-data/mouse1",
+    )
+    manager._image_dataset_folder = "C:/project-B/labeled-data/mouse1"
+
+    manager._remap_frame_indices(layer)
+
+    reason = rec.dataset_mismatch.calls[0][0]
+    assert "C:/project-A/labeled-data/mouse1" in reason
+    assert "C:/project-B/labeled-data/mouse1" in reason
+
+
+def test_frames_replaced_in_the_same_folder_names_one_folder_and_reports_the_lock(qtbot):
+    """Same folder: one folder named, and the lock stated."""
+    root = "C:/project/labeled-data/videoA"
+    layer = _points_bound_to(["labeled-data/videoA/imgA000.png"], root=root)
+
+    manager = LayerLifecycleManager(viewer=DummyViewer([layer]))
+    rec = connect_signal_recorders(manager)
+    manager._image_meta = ImageMetadata(paths=["labeled-data/videoA/renamed000.png"], root=root)
+    manager._image_dataset_folder = root
+
+    manager._remap_frame_indices(layer)
+
+    reason = rec.dataset_mismatch.calls[0][0]
+    assert "not:" not in reason
+    assert "still save to their original folder" in reason
+    assert "has been locked" in reason
+
+
+def test_unbound_layer_with_a_stale_root_is_told_where_it_will_actually_save(qtbot):
+    """Having no `dataset_folder` does not mean the layer saves into the open folder.
+
+    A rejected remap leaves `root` untouched, so this layer still writes to
+    `C:/elsewhere`. Naming the opened folder here would point the user at a folder that
+    is never written to.
+    """
+    layer = _points_bound_to(
+        ["labeled-data/videoA/img000.png"],
+        root="C:/elsewhere/labeled-data/videoA",
+        dataset_folder=NO_DATASET_FOLDER,
+    )
+
+    manager = LayerLifecycleManager(viewer=DummyViewer([layer]))
+    rec = connect_signal_recorders(manager)
+    manager._image_meta = ImageMetadata(
+        paths=["labeled-data/videoA/renamed000.png"],
+        root="C:/project/labeled-data/videoA",
+    )
+    manager._image_dataset_folder = "C:/project/labeled-data/videoA"
+
+    manager._remap_frame_indices(layer)
+
+    reason = rec.dataset_mismatch.calls[0][0]
+    assert "C:/elsewhere/labeled-data/videoA" in reason
+    assert "C:/project/labeled-data/videoA" in reason
+    assert "still save there" not in reason
+
+
+def test_dataset_mismatch_message_names_the_open_folder_not_a_stale_root(qtbot):
+    """The same-folder message points at the folder that was opened."""
+    layer = _points_bound_to(
+        ["labeled-data/videoA/img000.png"],
+        root=None,
+        dataset_folder=NO_DATASET_FOLDER,
+    )
+
+    manager = LayerLifecycleManager(viewer=DummyViewer([layer]))
+    rec = connect_signal_recorders(manager)
+    manager._image_meta = ImageMetadata(
+        paths=["labeled-data/videoA/renamed000.png"],
+        root="C:/project/labeled-data/videoA",
+    )
+    manager._image_dataset_folder = "C:/project/labeled-data/videoA"
+
+    manager._remap_frame_indices(layer)
+
+    reason = rec.dataset_mismatch.calls[0][0]
+    assert "C:/project/labeled-data/videoA" in reason
+    assert "its original folder" not in reason
+
+
+# ---------------------------------------------------------------------------
+# Locking a layer that no longer matches the frames on screen
+# ---------------------------------------------------------------------------
+def test_a_layer_left_on_another_folder_cannot_be_labelled():
+    """Frame association is positional, so an edit would land on the layer's own frame."""
+    layer = _points_bound_to(["labeled-data/videoA/imgA000.png"], root="C:/project/labeled-data/videoA")
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/videoB/imgB000.png"],
+        root="C:/project/labeled-data/videoB",
+    )
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.editable is False
+
+
+def test_a_layer_whose_frames_were_replaced_in_place_cannot_be_labelled():
+    """Same folder, different frame list: the indices are stale too."""
+    root = "C:/project/labeled-data/videoA"
+    layer = _points_bound_to(["labeled-data/videoA/imgA000.png"], root=root)
+
+    manager = _manager_showing(layer, paths=["labeled-data/videoA/renamed000.png"], root=root)
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.editable is False
+
+
+def test_reopening_the_layers_own_folder_gives_editing_back():
+    """The lock follows the open folder, not the layer."""
+    own_paths = ["labeled-data/videoA/imgA000.png"]
+    layer = _points_bound_to(own_paths, root="C:/project/labeled-data/videoA")
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/videoB/imgB000.png"],
+        root="C:/project/labeled-data/videoB",
+    )
+    manager._remap_frame_indices(layer)
+    assert layer.editable is False
+
+    manager._image_meta = ImageMetadata(paths=own_paths, root="C:/project/labeled-data/videoA")
+    manager._image_dataset_folder = "C:/project/labeled-data/videoA"
+    manager._remap_frame_indices(layer)
+
+    assert layer.editable is True
+
+
+def test_a_matching_layer_is_never_locked():
+    """A layer that follows the folder stays editable."""
+    new_paths = ["labeled-data/videoA/img001.png", "labeled-data/videoA/img000.png"]
+    layer = _points_bound_to(
+        ["labeled-data/videoA/img000.png", "labeled-data/videoA/img001.png"],
+        root="C:/project/labeled-data/videoA",
+    )
+
+    manager = _manager_showing(layer, paths=new_paths, root="C:/project/labeled-data/videoA")
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.metadata["paths"] == new_paths
+    assert layer.editable is True
+
+
+def test_frames_pruned_from_the_layers_own_folder_lock_and_give_the_remedy(qtbot):
+    """No in-plugin action clears this, so the message carries the fix from the DLC docs.
+
+    The layer holds a keypoint on `imgA001.png`, which is no longer in the folder.
+    """
+    root = "C:/project/labeled-data/videoA"
+    layer = _points_bound_to(
+        ["labeled-data/videoA/imgA000.png", "labeled-data/videoA/imgA001.png"],
+        root=root,
+    )
+    layer.data = np.array([[0, 1, 2], [1, 3, 4]], dtype=float)
+    layer.metadata["source_h5_stem"] = "CollectedData_John"
+
+    manager = _manager_showing(layer, paths=["labeled-data/videoA/imgA000.png"], root=root)
+    rec = connect_signal_recorders(manager)
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.editable is False
+
+    reason = rec.dataset_mismatch.calls[0][0]
+    assert "CollectedData_John.csv" in reason
+    assert "convertcsv2h5" in reason
+
+
+# ---------------------------------------------------------------------------
+# Inheriting root and paths from the open folder
+# ---------------------------------------------------------------------------
+def _points_keyed_without_paths(*, root):
+    """A keyed layer with no paths, as a numeric-index h5 produces.
+
+    `read_hdf` leaves `paths` empty when the frame index is numeric, but still records
+    `root` and `dataset_folder`, so a layer can name its dataset while listing no frames.
+    """
+    layer = make_nonempty_points("keyed")
+    layer.metadata = {"paths": [], "root": root, "dataset_folder": root}
+    return layer
+
+
+def test_image_context_without_a_dataset_folder_is_identified_by_its_root(tmp_path, monkeypatch):
+    """Opening a video must not read as a different dataset than the h5 beside it.
+
+    `read_video` rewrites videos/<name>.mp4 into labeled-data/<name>, so its root is the
+    annotations' own folder.
+    """
+    folder = tmp_path / "project" / "labeled-data" / "videoA"
+    folder.mkdir(parents=True)
+    root = str(folder)
+    new_paths = ["labeled-data/videoA/img000.png"]
+
+    layer = _points_keyed_without_paths(root=root)
+    image = make_image("videoA.mp4")
+    image.metadata = {"root": root}  # as read_video builds one: root, no dataset_folder
+
+    manager = LayerLifecycleManager(viewer=DummyViewer([image, layer]))
+    manager._setup_image_layer(image, reorder=False)
+    manager._image_meta = ImageMetadata(paths=list(new_paths), root=root)
+
+    warned = []
+    monkeypatch.setattr(manager, "_report_layer_left_on_previous_dataset", lambda ly: warned.append(ly))
+
+    manager._sync_points_layers_from_image_meta()
+
+    assert is_same_dataset(manager._image_dataset_folder, root)
+    assert warned == []
+    assert layer.metadata["paths"] == new_paths
+
+
+def test_sync_from_image_meta_refuses_paths_for_a_layer_from_another_dataset(monkeypatch):
+    layer = _points_keyed_without_paths(root="C:/project/labeled-data/videoA")
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/videoB/img000.png"],
+        root="C:/project/labeled-data/videoB",
+    )
+
+    warned = []
+    monkeypatch.setattr(manager, "_report_layer_left_on_previous_dataset", lambda ly: warned.append(ly))
+
+    manager._sync_points_layers_from_image_meta()
+
+    assert layer.metadata["paths"] == []
+    assert layer.metadata["root"] == "C:/project/labeled-data/videoA"
+    assert warned == [layer]
+
+
+def test_sync_from_image_meta_still_inherits_paths_for_its_own_dataset():
+    new_paths = ["labeled-data/videoA/img000.png"]
+    layer = _points_keyed_without_paths(root="C:/project/labeled-data/videoA")
+
+    manager = _manager_showing(layer, paths=new_paths, root="C:/project/labeled-data/videoA")
+
+    manager._sync_points_layers_from_image_meta()
+
+    assert layer.metadata["paths"] == new_paths
+
+
+def test_sync_from_image_meta_records_the_dataset_folder_it_inherits_from():
+    layer = make_points("placeholder")
+    layer.metadata = {"project": "C:/project"}
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/videoA/img000.png"],
+        root="C:/project/labeled-data/videoA",
+    )
+
+    manager._sync_points_layers_from_image_meta()
+
+    assert layer.metadata["dataset_folder"] == "C:/project/labeled-data/videoA"
+
+
+def test_wire_points_layer_refuses_paths_from_another_dataset(monkeypatch, fake_store):
+    """Wiring inherits missing paths too, so it asks the same question."""
+    layer = _points_keyed_without_paths(root="C:/project/labeled-data/videoA")
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/videoB/img000.png"],
+        root="C:/project/labeled-data/videoB",
+    )
+    monkeypatch.setattr(manager, "validate_header", lambda _layer: True)
+
+    warned = []
+    monkeypatch.setattr(manager, "_report_layer_left_on_previous_dataset", lambda ly: warned.append(ly))
+
+    manager._wire_points_layer(layer)
+
+    assert layer.metadata["paths"] == []
+    assert layer.metadata["root"] == "C:/project/labeled-data/videoA"
+    assert warned == [layer]
+
+
+def test_wire_points_layer_records_the_dataset_folder_it_inherits_from(monkeypatch, fake_store):
+    """A layer with no dataset of its own keeps the folder it took its paths from."""
+    new_paths = ["labeled-data/videoA/img000.png"]
+    layer = make_nonempty_points("placeholder")
+    layer.metadata = {"project": "C:/project"}
+
+    manager = _manager_showing(layer, paths=new_paths, root="C:/project/labeled-data/videoA")
+    monkeypatch.setattr(manager, "validate_header", lambda _layer: True)
+
+    manager._wire_points_layer(layer)
+
+    assert layer.metadata["paths"] == new_paths
+    assert layer.metadata["dataset_folder"] == "C:/project/labeled-data/videoA"
+
+
+def test_wire_points_layer_says_nothing_when_no_image_is_open(monkeypatch, fake_store):
+    """Loading annotations first is the normal way in, not a mismatch."""
+    layer = _points_bound_to(
+        ["labeled-data/videoA/img000.png"],
+        root="C:/project/labeled-data/videoA",
+    )
+
+    manager = LayerLifecycleManager(viewer=DummyViewer([layer]))
+    monkeypatch.setattr(manager, "validate_header", lambda _layer: True)
+
+    warned = []
+    monkeypatch.setattr(manager, "_report_layer_left_on_previous_dataset", lambda ly: warned.append(ly))
+
+    manager._wire_points_layer(layer)
+
+    assert warned == []
+
+
+def test_an_unbound_layer_binds_to_the_dataset_it_adopts(monkeypatch):
+    """A config placeholder must stop being unbound once it takes a folder."""
+    layer = make_points("placeholder")
+    layer.metadata = {"project": "C:/project"}
+
+    manager = _manager_showing(
+        layer,
+        paths=["labeled-data/videoA/img000.png"],
+        root="C:/project/labeled-data/videoA",
+    )
+    manager._remap_frame_indices(layer)
+
+    assert layer.metadata["dataset_folder"] == "C:/project/labeled-data/videoA"
+
+    # Now a different folder reusing the same frame names must be refused.
+    manager._image_meta = ImageMetadata(
+        paths=["labeled-data/videoB/img000.png"],
+        root="C:/project/labeled-data/videoB",
+    )
+    manager._image_dataset_folder = "C:/project/labeled-data/videoB"
+
+    warned = []
+    monkeypatch.setattr(manager, "_report_layer_left_on_previous_dataset", lambda ly: warned.append(ly))
+
+    manager._remap_frame_indices(layer)
+
+    assert layer.metadata["root"] == "C:/project/labeled-data/videoA"
+    assert warned == [layer]
+
+
+def _adopt_via_setup_points_layer(manager, layer, monkeypatch):
+    monkeypatch.setattr(manager, "validate_header", lambda ly: True)
+    manager._setup_points_layer(layer, allow_merge=False)
+
+
+def _adopt_via_sync_from_image_meta(manager, layer, monkeypatch):
+    manager._sync_points_layers_from_image_meta()
+
+
+ADOPTION_ENTRY_POINTS = {
+    "setup_points_layer": _adopt_via_setup_points_layer,
+    "sync_from_image_meta": _adopt_via_sync_from_image_meta,
+}
+
+
+@pytest.mark.parametrize("entry_point", sorted(ADOPTION_ENTRY_POINTS))
+def test_taking_context_from_the_open_folder_always_binds_the_layer(
+    qtbot,
+    fake_store,
+    monkeypatch,
+    entry_point,
+):
+    """Whichever entry point hands a layer image context must also record dataset_folder."""
+    open_root = "C:/project/labeled-data/videoB"
+    open_paths = ["labeled-data/videoB/img000.png"]
+
+    layer = make_points("unbound")
+    layer.metadata = {}
+
+    manager = _manager_showing(layer, paths=open_paths, root=open_root)
+
+    ADOPTION_ENTRY_POINTS[entry_point](manager, layer, monkeypatch)
+
+    # Guards the assertion below against passing vacuously if adoption stops happening.
+    assert layer.metadata.get("root") == open_root
+    assert layer.metadata.get("dataset_folder") == open_root
+
+
+@pytest.mark.parametrize("entry_point", sorted(ADOPTION_ENTRY_POINTS))
+def test_a_layer_holding_its_own_paths_takes_no_context_before_remap(
+    qtbot,
+    fake_store,
+    monkeypatch,
+    entry_point,
+):
+    """Neither entry point hands a root to a layer that already lists frames.
+
+    `root` and `paths` route a save together, so a layer that took one folder's root
+    while listing another's frames would save into the first and be indexed against the
+    second. Such a layer takes its root from `_remap_frame_indices`, once the paths
+    update is verified; binding it here would also mark it as belonging to a folder its
+    frames were never checked against, which silences the mismatch report.
+    """
+    open_root = "C:/project/labeled-data/videoB"
+    open_paths = ["labeled-data/videoB/img000.png"]
+    own_paths = ["labeled-data/videoA/img000.png"]
+
+    layer = make_points("unbound")
+    layer.metadata = {"paths": list(own_paths)}
+
+    manager = _manager_showing(layer, paths=open_paths, root=open_root)
+
+    ADOPTION_ENTRY_POINTS[entry_point](manager, layer, monkeypatch)
+
+    assert layer.metadata.get("root") is None
+    assert layer.metadata.get("dataset_folder") is None
+    assert layer.metadata.get("paths") == own_paths
diff --git a/src/napari_deeplabcut/_tests/core/test_metadata.py b/src/napari_deeplabcut/_tests/core/test_metadata.py
index d6cbad65..28872ea7 100644
--- a/src/napari_deeplabcut/_tests/core/test_metadata.py
+++ b/src/napari_deeplabcut/_tests/core/test_metadata.py
@@ -39,42 +39,6 @@ def __init__(self, metadata=None, name="dummy-layer"):
 # -----------------------------------------------------------------------------
 
 
-@pytest.mark.parametrize(
-    ("path_str", "expected"),
-    [
-        ("project/labeled-data/mouse1", True),
-        ("project/LABELED-DATA/mouse1", True),
-        ("project/labeled-data", False),
-        ("project/images/mouse1", False),
-    ],
-)
-def test_is_dlc_dataset_root(path_str: str, expected: bool):
-    assert metadata_mod._is_dlc_dataset_root(Path(path_str)) is expected
-
-
-@pytest.mark.parametrize(
-    ("paths", "expected"),
-    [
-        (None, False),
-        ([], False),
-        (["images/img001.png"], False),
-        (["labeled-data/test/img001.png"], True),
-        ([r"labeled-data\test\img001.png"], True),
-    ],
-)
-def test_paths_look_like_labeled_data(paths, expected):
-    assert metadata_mod._paths_look_like_labeled_data(paths) is expected
-
-
-def test_looks_like_project_root_true_when_same_path(tmp_path: Path):
-    assert metadata_mod._looks_like_project_root(str(tmp_path), str(tmp_path)) is True
-
-
-def test_looks_like_project_root_false_when_different(tmp_path: Path):
-    other = tmp_path / "other"
-    assert metadata_mod._looks_like_project_root(str(tmp_path), str(other)) is False
-
-
 def test_infer_image_root_prefers_explicit_root(tmp_path: Path):
     p = tmp_path / "images" / "img001.png"
     p.parent.mkdir(parents=True)
@@ -188,43 +152,49 @@ def test_sync_points_from_image_fills_missing_fields():
     assert synced.name == "images"
 
 
-def test_sync_points_from_image_overrides_project_root_with_dataset_root(tmp_path: Path):
+def test_sync_points_from_image_never_rewrites_a_root_that_is_already_set(tmp_path: Path):
     project_root = tmp_path / "project"
-    dataset_root = project_root / "labeled-data" / "mouse1"
-    dataset_root.mkdir(parents=True)
+    good_points_root = project_root / "labeled-data" / "mouse1"
+    other_dataset_root = project_root / "labeled-data" / "mouse2"
+    good_points_root.mkdir(parents=True)
+    other_dataset_root.mkdir(parents=True)
 
-    image_meta = ImageMetadata(
-        root=str(dataset_root),
-        paths=[str(dataset_root / "img001.png")],
-        name="images",
-    )
+    image_meta = ImageMetadata(root=str(other_dataset_root))
     points_meta = PointsMetadata(
-        root=str(project_root),  # stale / wrong
+        root=str(good_points_root),
         project=str(project_root),
     )
 
     synced = metadata_mod.sync_points_from_image(image_meta, points_meta)
 
-    assert synced.root == str(dataset_root)
+    # Which dataset a layer belongs to is settled by dataset_folder, not re-derived here.
+    assert synced.root == str(good_points_root)
 
 
-def test_sync_points_from_image_keeps_existing_dataset_root_when_already_good(tmp_path: Path):
+def test_sync_points_from_image_does_not_seed_root_beside_existing_paths(tmp_path: Path):
     project_root = tmp_path / "project"
-    good_points_root = project_root / "labeled-data" / "mouse1"
-    other_dataset_root = project_root / "labeled-data" / "mouse2"
-    good_points_root.mkdir(parents=True)
-    other_dataset_root.mkdir(parents=True)
+    layer_dataset = project_root / "labeled-data" / "mouse1"
+    opened_dataset = project_root / "labeled-data" / "mouse2"
+    layer_dataset.mkdir(parents=True)
+    opened_dataset.mkdir(parents=True)
 
-    image_meta = ImageMetadata(root=str(other_dataset_root))
-    points_meta = PointsMetadata(
-        root=str(good_points_root),
-        project=str(project_root),
+    image_meta = ImageMetadata(
+        root=str(opened_dataset),
+        paths=[str(opened_dataset / "img001.png")],
+        shape=[100, 200],
+        name="images",
     )
+    points_meta = PointsMetadata(paths=[str(layer_dataset / "img001.png")])
 
     synced = metadata_mod.sync_points_from_image(image_meta, points_meta)
 
-    # already a valid dataset root -> do not overwrite
-    assert synced.root == str(good_points_root)
+    # root routes the save, paths says what it is indexed against: seeding one beside the
+    # other is the split that sends annotations to a folder they did not come from.
+    assert synced.root is None
+    assert synced.paths == [str(layer_dataset / "img001.png")]
+    # Fields that do not route a save are still seeded.
+    assert tuple(synced.shape) == (100, 200)
+    assert synced.name == "images"
 
 
 def test_ensure_metadata_models_accepts_dicts_and_models():
diff --git a/src/napari_deeplabcut/_tests/core/test_project_paths.py b/src/napari_deeplabcut/_tests/core/test_project_paths.py
index 92c19245..efbd571e 100644
--- a/src/napari_deeplabcut/_tests/core/test_project_paths.py
+++ b/src/napari_deeplabcut/_tests/core/test_project_paths.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+import os
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -87,6 +88,70 @@ def test_path_match_policy_ordered_depths():
     assert paths_mod.PathMatchPolicy.ORDERED_DEPTHS.depths == (3, 2, 1)
 
 
+def test_dataset_folder_is_absolute_two_projects_stay_distinct(tmp_path: Path):
+    """The dataset folder name alone repeats across projects; the resolved path does not."""
+    a = tmp_path / "project-A" / "labeled-data" / "mouse1"
+    b = tmp_path / "project-B" / "labeled-data" / "mouse1"
+    a.mkdir(parents=True)
+    b.mkdir(parents=True)
+
+    key_a = paths_mod.resolve_dataset_folder(a)
+    key_b = paths_mod.resolve_dataset_folder(b)
+
+    assert key_a != key_b
+    assert key_a == paths_mod.resolve_dataset_folder(str(a))
+    assert paths_mod.resolve_dataset_folder(None) is None
+
+
+def test_points_metadata_round_trip_preserves_dataset_folder():
+    """Identity must survive the metadata sync that runs on every image insert."""
+    from napari_deeplabcut.config.models import PointsMetadata
+
+    meta = PointsMetadata(root="C:/p/labeled-data/videoA", dataset_folder="C:/p/labeled-data/videoA")
+
+    assert PointsMetadata(**meta.model_dump()).dataset_folder == "C:/p/labeled-data/videoA"
+
+
+def test_is_same_dataset_matches_identical_and_rejects_distinct(tmp_path: Path):
+    a = tmp_path / "labeled-data" / "videoA"
+    b = tmp_path / "labeled-data" / "videoB"
+    a.mkdir(parents=True)
+    b.mkdir(parents=True)
+
+    assert paths_mod.is_same_dataset(str(a), str(a)) is True
+    assert paths_mod.is_same_dataset(str(a), str(b)) is False
+    assert paths_mod.is_same_dataset(None, str(a)) is False
+    assert paths_mod.is_same_dataset(str(a), None) is False
+
+
+def test_is_same_dataset_fails_closed_for_missing_folders(tmp_path: Path):
+    """Two spellings that cannot be compared on disk are not assumed to be the same."""
+    assert paths_mod.is_same_dataset(str(tmp_path / "gone-a"), str(tmp_path / "gone-b")) is False
+
+
+def test_is_same_dataset_sees_through_a_second_route_to_one_folder(tmp_path: Path):
+    """A mapped drive against its UNC path is the real case; a symlink stands in for it."""
+    real = tmp_path / "labeled-data" / "videoA"
+    real.mkdir(parents=True)
+    link = tmp_path / "via-link"
+    try:
+        link.symlink_to(real, target_is_directory=True)
+    except (OSError, NotImplementedError):
+        pytest.skip("symlink creation not permitted here")
+
+    # Deliberately unresolved, so the strings differ and the on-disk check is what decides.
+    assert str(link) != str(real)
+    assert paths_mod.is_same_dataset(str(link), str(real)) is True
+
+
+@pytest.mark.skipif(os.name != "nt", reason="path case is only insensitive on Windows")
+def test_is_same_dataset_ignores_case_on_windows(tmp_path: Path):
+    a = tmp_path / "labeled-data" / "videoA"
+    a.mkdir(parents=True)
+
+    assert paths_mod.is_same_dataset(str(a), str(a).upper()) is True
+
+
 def test_find_matching_depth_prefers_deepest_first_match():
     old_paths = [
         "/project/labeled-data/mouse1/img001.png",
diff --git a/src/napari_deeplabcut/_tests/core/test_remap.py b/src/napari_deeplabcut/_tests/core/test_remap.py
index 869864ad..aa74efd5 100644
--- a/src/napari_deeplabcut/_tests/core/test_remap.py
+++ b/src/napari_deeplabcut/_tests/core/test_remap.py
@@ -1,9 +1,12 @@
 import logging
 
 import numpy as np
+import pytest
 
 from napari_deeplabcut.core.project_paths import PathMatchPolicy
 from napari_deeplabcut.core.remap import (
+    LOST_ANNOTATED_FRAMES,
+    AnnotationFramesMissingError,
     build_frame_index_map,
     remap_layer_data_by_paths,
     remap_time_indices,
@@ -281,6 +284,123 @@ def test_remap_warns_on_duplicate_canonical_keys(caplog):
     assert any("Duplicate canonical keys" in w for w in res.warnings)
 
 
+def test_ambiguous_depth1_remap_is_rejected_and_refuses_paths_update():
+    """A basename-only match that is not bijective must not be trusted.
+
+    Callers key further metadata updates off ``accept_paths_update``, so it has to stay
+    False here even though a depth was found.
+    """
+    # No shared 3- or 2-level suffix, so matching falls back to bare basenames, where
+    # both old paths collapse onto the same key.
+    old_paths = ["A/a/img0.png", "B/b/img0.png"]
+    new_paths = ["X/x/img0.png", "Y/y/img1.png"]
+
+    data = np.array([[0.0, 1.0, 2.0], [1.0, 3.0, 4.0]], dtype=float)
+
+    res = remap_layer_data_by_paths(
+        data=data,
+        old_paths=old_paths,
+        new_paths=new_paths,
+        time_col=0,
+        policy=PathMatchPolicy.ORDERED_DEPTHS,
+    )
+
+    assert res.depth_used == 1
+    assert res.is_ambiguous is True
+    assert res.accept_paths_update is False
+    assert res.applied is False
+    assert res.changed is False
+
+
+def test_fully_colliding_basenames_are_rejected_not_read_as_aligned():
+    """Equal key lists at depth=1 are a name collision, not a match.
+
+    Both sides canonicalize to ["img0.png", "img0.png"], so equality alone cannot tell
+    two folders of identically named frames from one folder in its original order.
+    """
+    old_paths = ["projA/labeled-data/mouse1/img0.png", "projA/labeled-data/mouse2/img0.png"]
+    new_paths = ["projB/labeled-data/catX/img0.png", "projB/labeled-data/catY/img0.png"]
+
+    data = np.array([[0.0, 1.0, 2.0], [1.0, 3.0, 4.0]], dtype=float)
+
+    res = remap_layer_data_by_paths(
+        data=data,
+        old_paths=old_paths,
+        new_paths=new_paths,
+        time_col=0,
+        policy=PathMatchPolicy.ORDERED_DEPTHS,
+    )
+
+    assert res.depth_used == 1
+    assert res.is_ambiguous is True
+    assert res.accept_paths_update is False
+
+
+def test_annotated_frame_losing_its_path_is_refused(caplog):
+    """A keypoint on a vanished frame has no correct destination, so the remap refuses.
+
+    Frame association is positional: re-keying the layer would move those keypoints onto
+    whichever path took their position, and the next save would write them there.
+    """
+    old_paths = [f"p/labeled-data/vidA/img{i:03d}.png" for i in range(5)]
+    new_paths = [p for p in old_paths if not p.endswith("img002.png")]
+
+    with caplog.at_level(logging.WARNING, logger="napari_deeplabcut.core.remap"):
+        with pytest.raises(AnnotationFramesMissingError) as excinfo:
+            remap_layer_data_by_paths(
+                data=np.array([[2.0, 10.0, 10.0]]),
+                old_paths=old_paths,
+                new_paths=new_paths,
+                time_col=0,
+            )
+
+    assert str(excinfo.value).startswith(LOST_ANNOTATED_FRAMES)
+    assert "lost their path" in caplog.text
+
+
+def test_frames_vanishing_without_keypoints_are_not_refused():
+    """Only frames carrying keypoints have anything to lose."""
+    old_paths = [f"p/labeled-data/vidA/img{i:03d}.png" for i in range(5)]
+    new_paths = [p for p in old_paths if not p.endswith("img002.png")]
+
+    res = remap_layer_data_by_paths(
+        data=np.array([[0.0, 10.0, 10.0]]),
+        old_paths=old_paths,
+        new_paths=new_paths,
+        time_col=0,
+    )
+
+    assert res.accept_paths_update is True
+
+
+def test_basename_only_match_is_accepted_and_cannot_prove_identity():
+    """`LayerLifecycleManager` gates on `dataset_folder` for that reason."""
+    res = remap_layer_data_by_paths(
+        data=np.array([[0.0, 1.0, 2.0], [1.0, 3.0, 4.0]], dtype=float),
+        old_paths=["p/labeled-data/videoA/img000.png", "p/labeled-data/videoA/img001.png"],
+        new_paths=["p/labeled-data/videoB/img000.png", "p/labeled-data/videoB/img001.png"],
+        time_col=0,
+        policy=PathMatchPolicy.ORDERED_DEPTHS,
+    )
+
+    assert res.depth_used == 1
+    assert res.accept_paths_update is True
+
+
+def test_no_overlap_remap_refuses_paths_update():
+    """The other rejection path callers depend on: nothing matched at any depth."""
+    res = remap_layer_data_by_paths(
+        data=np.array([[0.0, 1.0, 2.0]], dtype=float),
+        old_paths=["A/a/img0.png"],
+        new_paths=["B/b/other.png"],
+        time_col=0,
+        policy=PathMatchPolicy.ORDERED_DEPTHS,
+    )
+
+    assert res.depth_used is None
+    assert res.accept_paths_update is False
+
+
 def test_remap_warns_on_low_overlap_ratio(caplog):
     caplog.set_level(logging.WARNING)
 
diff --git a/src/napari_deeplabcut/_tests/e2e/test_folder_switch_integrity.py b/src/napari_deeplabcut/_tests/e2e/test_folder_switch_integrity.py
new file mode 100644
index 00000000..128bec57
--- /dev/null
+++ b/src/napari_deeplabcut/_tests/e2e/test_folder_switch_integrity.py
@@ -0,0 +1,273 @@
+# src/napari_deeplabcut/_tests/e2e/test_folder_switch_integrity.py
+"""Switching the image folder underneath a surviving Points layer.
+
+Opening a labeled folder adopts its image context onto every non-Image layer. When the
+new folder's frames cannot be mapped onto a layer's existing ones, that layer must not be
+half-adopted: rebinding ``root`` while ``paths`` still names the previous folder yields an
+annotation file written into one dataset but indexed against another.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pandas as pd
+import pytest
+from napari.layers import Image, Points
+
+from .utils import (
+    _make_project_with_two_labeled_folders,
+    _make_two_projects_sharing_a_video_name,
+    _read_h5_keypoints,
+    _write_dlc_config,
+    _write_frames,
+)
+
+
+def _points_layers(viewer):
+    return [ly for ly in viewer.layers if isinstance(ly, Points)]
+
+
+def _open_folder(viewer, qtbot, folder: Path, *, expect_points: bool) -> None:
+    viewer.open(str(folder), plugin="napari-deeplabcut")
+    if expect_points:
+        qtbot.waitUntil(lambda: bool(_points_layers(viewer)), timeout=10_000)
+    else:
+        qtbot.waitUntil(
+            lambda: any(isinstance(ly, Image) for ly in viewer.layers),
+            timeout=10_000,
+        )
+    qtbot.wait(100)
+
+
+def _remove_image_layers(viewer, qtbot) -> None:
+    for layer in [ly for ly in viewer.layers if isinstance(ly, Image)]:
+        viewer.layers.remove(layer)
+    qtbot.wait(100)
+
+
+def _dataset_names_in_index(df: pd.DataFrame) -> set[str]:
+    """Dataset-folder component of each row key."""
+    if isinstance(df.index, pd.MultiIndex):
+        return {str(parts[-2]) for parts in df.index}
+    return {Path(str(v)).parent.name for v in df.index}
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_unmappable_folder_switch_leaves_points_layer_bound_to_its_own_dataset(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+) -> None:
+    """videoB's frames cannot be mapped onto videoA's, so the layer must not be rebound."""
+    _project, _config_path, folder_a, folder_b, _gt_path = _make_project_with_two_labeled_folders(tmp_path)
+
+    _open_folder(viewer, qtbot, folder_a, expect_points=True)
+
+    layer = _points_layers(viewer)[0]
+    paths_before = list(layer.metadata.get("paths") or [])
+    root_before = layer.metadata.get("root")
+    assert paths_before, "Expected the folder reader to bind frame paths to the Points layer"
+
+    _remove_image_layers(viewer, qtbot)
+    _open_folder(viewer, qtbot, folder_b, expect_points=False)
+
+    assert list(layer.metadata.get("paths") or []) == paths_before, (
+        "Points layer frame paths changed after opening an unrelated folder"
+    )
+    assert layer.metadata.get("root") == root_before, (
+        "Points layer root was rebound to a folder whose frames it does not contain"
+    )
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_unmappable_folder_switch_does_not_write_annotations_into_new_folder(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+    overwrite_confirm,
+) -> None:
+    """Saving after an unmappable switch must not drop a foreign-indexed file into videoB."""
+    overwrite_confirm.capture()
+
+    _project, _config_path, folder_a, folder_b, gt_path = _make_project_with_two_labeled_folders(tmp_path)
+
+    _open_folder(viewer, qtbot, folder_a, expect_points=True)
+    layer = _points_layers(viewer)[0]
+
+    _remove_image_layers(viewer, qtbot)
+    _open_folder(viewer, qtbot, folder_b, expect_points=False)
+
+    viewer.layers.selection.select_only(layer)
+    keypoint_controls._save_layers_dialog(selected=True)
+    qtbot.wait(200)
+
+    stray = sorted(p.name for p in folder_b.glob("CollectedData*"))
+    assert not stray, f"Annotations were written into {folder_b.name}: {stray}"
+
+    assert _dataset_names_in_index(_read_h5_keypoints(gt_path)) == {"videoA"}
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_identical_frame_names_in_another_folder_do_not_migrate_the_layer(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+    overwrite_confirm,
+) -> None:
+    """videoB reuses videoA's frame names, which is the DLC norm, not evidence of identity.
+
+    Matching on basenames alone would give a perfect 1:1 map here and silently carry the
+    annotation onto a different dataset's frames.
+    """
+    overwrite_confirm.capture()
+
+    _project, _config_path, folder_a, folder_b, gt_path = _make_project_with_two_labeled_folders(
+        tmp_path,
+        b_frames=("imgA000.png",),
+    )
+
+    _open_folder(viewer, qtbot, folder_a, expect_points=True)
+    layer = _points_layers(viewer)[0]
+    paths_before = list(layer.metadata.get("paths") or [])
+
+    _remove_image_layers(viewer, qtbot)
+    _open_folder(viewer, qtbot, folder_b, expect_points=False)
+
+    assert Path(str(layer.metadata.get("root"))).name == "videoA"
+    assert list(layer.metadata.get("paths") or []) == paths_before
+
+    viewer.layers.selection.select_only(layer)
+    keypoint_controls._save_layers_dialog(selected=True)
+    qtbot.wait(200)
+
+    stray = sorted(p.name for p in folder_b.glob("CollectedData*"))
+    assert not stray, f"Annotations migrated into {folder_b.name}: {stray}"
+    assert _dataset_names_in_index(_read_h5_keypoints(gt_path)) == {"videoA"}
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_layer_does_not_follow_a_different_project_using_the_same_video_name(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+    overwrite_confirm,
+) -> None:
+    """Re-labelling the same footage in a fresh project is an ordinary DLC workflow.
+
+    Both projects then hold `labeled-data/mouse1/img000.png`, which is identical at every
+    canonicalization depth: the project root is not part of the key. A layer from the
+    first project must not silently rebind to, or be saved into, the second.
+    """
+    overwrite_confirm.capture()
+
+    proj = _make_two_projects_sharing_a_video_name(tmp_path)
+
+    _open_folder(viewer, qtbot, proj.folder_a, expect_points=True)
+    layer = _points_layers(viewer)[0]
+    root_before = Path(str(layer.metadata.get("root")))
+    project_before = layer.metadata.get("project")
+
+    _remove_image_layers(viewer, qtbot)
+    _open_folder(viewer, qtbot, proj.folder_b, expect_points=False)
+
+    assert Path(str(layer.metadata.get("root"))) == root_before, (
+        f"Layer rebound from {project_before} to another project's dataset of the same name"
+    )
+
+    viewer.layers.selection.select_only(layer)
+    keypoint_controls._save_layers_dialog(selected=True)
+    qtbot.wait(200)
+
+    stray = sorted(p.name for p in proj.folder_b.glob("CollectedData*"))
+    assert not stray, f"Annotations from {project_before} were written into project-B: {stray}"
+
+
+def _write_multi_row_gt(path: Path, *, scorer: str, folder_name: str, rows: dict[str, list[float]]) -> Path:
+    """GT file whose row keys may name frames that are not on disk."""
+    cols = pd.MultiIndex.from_product(
+        [[scorer], ["bodypart1", "bodypart2"], ["x", "y"]],
+        names=["scorer", "bodyparts", "coords"],
+    )
+    index = pd.MultiIndex.from_tuples([("labeled-data", folder_name, name) for name in rows])
+    df = pd.DataFrame(list(rows.values()), index=index, columns=cols)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_hdf(path, key="df_with_missing", mode="w")
+    df.to_csv(str(path).replace(".h5", ".csv"))
+    return path
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_keypoints_on_a_deleted_frame_do_not_spread_to_other_frames(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+    overwrite_confirm,
+) -> None:
+    """A row key with no file on disk must not be re-keyed onto a frame that does exist.
+
+    Frame association is positional. Re-keying moves those keypoints onto whichever path
+    took their index, and each save walks them one frame further down the folder.
+    """
+    overwrite_confirm.capture()
+
+    project = tmp_path / "project"
+    folder = _write_frames(project / "labeled-data" / "videoA", ("img001.png", "img002.png"))
+    _write_dlc_config(project, bodyparts=("bodypart1", "bodypart2"))
+
+    gt_path = _write_multi_row_gt(
+        folder / "CollectedData_John.h5",
+        scorer="John",
+        folder_name="videoA",
+        rows={
+            "img000.png": [10.0, 20.0, 30.0, 40.0],  # deleted from disk, carries keypoints
+            "img001.png": [50.0, 60.0, 70.0, 80.0],
+            "img002.png": [90.0, 100.0, 110.0, 120.0],
+        },
+    )
+
+    _open_folder(viewer, qtbot, folder, expect_points=True)
+    layer = _points_layers(viewer)[0]
+
+    assert len(layer.metadata.get("paths") or []) == 3, "The layer must keep its own frame list, not the folder's"
+
+    viewer.layers.selection.select_only(layer)
+    keypoint_controls._save_layers_dialog(selected=True)
+    qtbot.wait(300)
+
+    df = _read_h5_keypoints(gt_path)
+    by_frame = {str(idx[-1]): row.to_numpy(dtype=float).tolist() for idx, row in df.iterrows()}
+
+    # Spreading overwrites a real frame with the deleted frame's coordinates.
+    assert by_frame["img000.png"] == [10.0, 20.0, 30.0, 40.0]
+    assert by_frame["img001.png"] == [50.0, 60.0, 70.0, 80.0]
+    assert by_frame["img002.png"] == [90.0, 100.0, 110.0, 120.0]
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_frames_added_to_the_folder_still_remap(viewer, keypoint_controls, qtbot, tmp_path) -> None:
+    """The DLC refine loop only adds frames, so it must keep working.
+
+    `extract_outlier_frames` writes new frames into labeled-data/<video> and never removes
+    one, so no annotated row can lose its path.
+    """
+    project = tmp_path / "project"
+    folder = _write_frames(project / "labeled-data" / "videoA", ("img000.png", "img001.png"))
+    _write_dlc_config(project, bodyparts=("bodypart1", "bodypart2"))
+
+    _write_multi_row_gt(
+        folder / "CollectedData_John.h5",
+        scorer="John",
+        folder_name="videoA",
+        rows={"img000.png": [10.0, 20.0, 30.0, 40.0]},
+    )
+
+    _open_folder(viewer, qtbot, folder, expect_points=True)
+    layer = _points_layers(viewer)[0]
+
+    assert len(layer.metadata.get("paths") or []) == 2, "An added frame must not block the remap"
diff --git a/src/napari_deeplabcut/_tests/e2e/test_overwrite_and_merge.py b/src/napari_deeplabcut/_tests/e2e/test_overwrite_and_merge.py
index fffbd708..07abcf96 100644
--- a/src/napari_deeplabcut/_tests/e2e/test_overwrite_and_merge.py
+++ b/src/napari_deeplabcut/_tests/e2e/test_overwrite_and_merge.py
@@ -3,7 +3,7 @@
 import numpy as np
 import pandas as pd
 import pytest
-from napari.layers import Points
+from napari.layers import Image, Points
 
 from napari_deeplabcut.config.models import AnnotationKind, DLCHeaderModel
 from napari_deeplabcut.core.io import _read_hdf_any_key
@@ -17,6 +17,9 @@
     _make_project_config_and_frames_no_gt,
     _seed_gt_and_machine_outlier_dataset,
     _set_or_add_bodypart_xy,
+    _write_dlc_config,
+    _write_frames,
+    _write_keypoints_h5,
 )
 
 logger = logging.getLogger(__name__)
@@ -655,3 +658,181 @@ def _gt_has_expected_rows() -> bool:
         machine_before,
         check_dtype=False,
     )
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_opening_the_same_folder_twice_keeps_one_annotation_layer(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+) -> None:
+    """A folder open re-reads its h5, so opening one twice would load it twice.
+
+    Two layers on one file both save to it, and whichever is saved last wins. Save
+    routing branches on the selection, so the duplicate does not block a save; it makes
+    the stale copy selectable and indistinguishable from the live one.
+    """
+    _project, _config_path, labeled, _h5_path = _make_minimal_dlc_project(tmp_path)
+
+    viewer.open(str(labeled), plugin="napari-deeplabcut")
+    qtbot.waitUntil(lambda: len([ly for ly in viewer.layers if isinstance(ly, Points)]) == 1, timeout=10_000)
+    original = next(ly for ly in viewer.layers if isinstance(ly, Points))
+
+    for image_layer in [ly for ly in viewer.layers if not isinstance(ly, Points)]:
+        viewer.layers.remove(image_layer)
+    qtbot.wait(100)
+
+    viewer.open(str(labeled), plugin="napari-deeplabcut")
+    qtbot.wait(600)  # the reloaded copy is removed on a deferred timer
+
+    points_layers = [ly for ly in viewer.layers if isinstance(ly, Points)]
+    assert len(points_layers) == 1, f"Expected the reloaded copy to be dropped, got {[ly.name for ly in points_layers]}"
+    assert points_layers[0] is original, "The surviving layer must be the one already loaded, not the reloaded copy"
+
+
+@pytest.mark.xfail(
+    strict=True,
+    raises=AssertionError,
+    reason=(
+        "Removing a bodypart from config.yaml and loading that config drops its annotations. "
+        "The merge prompt keys on added keypoints only, so a removal applies silently, and "
+        "restore_dlc_on_disk_header_shape then drops the column on save. Remove this marker "
+        "when the plugin refuses or reports the removal."
+    ),
+)
+@pytest.mark.usefixtures("qtbot")
+def test_config_dropping_a_bodypart_does_not_delete_its_annotations(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+    overwrite_confirm,
+) -> None:
+    """A config edit must not silently delete annotations already on disk.
+
+    DeepLabCut itself treats the config as a view: `merge_annotateddatasets` reindexes to
+    `cfg["bodyparts"]` and leaves labeled-data untouched. The plugin must not be more
+    destructive than that.
+    """
+    overwrite_confirm.capture()
+
+    project, _config_path, labeled, h5_path = _make_minimal_dlc_project(tmp_path)
+    _write_keypoints_h5(
+        h5_path,
+        scorer="John",
+        img_rel=("labeled-data", "test", "img000.png"),
+        bodyparts=("bodypart1", "bodypart2"),
+        values=[10.0, 20.0, 30.0, 40.0],
+    )
+
+    viewer.open(str(labeled), plugin="napari-deeplabcut")
+    qtbot.waitUntil(lambda: any(isinstance(ly, Points) for ly in viewer.layers), timeout=10_000)
+
+    # The project now declares only bodypart1.
+    reduced_config = _write_dlc_config(project, bodyparts=("bodypart1",))
+    viewer.open(str(reduced_config), plugin="napari-deeplabcut")
+    qtbot.wait(600)
+
+    layer = _get_points_layer_with_data(viewer)
+    viewer.layers.selection.select_only(layer)
+    keypoint_controls._save_layers_dialog(selected=True)
+    qtbot.wait(300)
+
+    saved = _read_hdf_any_key(h5_path)
+    bodyparts = set(saved.columns.get_level_values("bodyparts"))
+    assert "bodypart2" in bodyparts, "Annotations for a bodypart removed from config were deleted"
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_opening_a_folder_does_not_take_bodyparts_from_config(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+    overwrite_confirm,
+) -> None:
+    """Opening a folder reads the header from the h5, never from the nearby config.
+
+    `read_hdf_single` consults the nearest config for the colormap only. Widening that to
+    bodyparts would make every folder open silently drop annotations the config no longer
+    declares, with no user action at all.
+    """
+    overwrite_confirm.capture()
+
+    project, _config_path, labeled, h5_path = _make_minimal_dlc_project(tmp_path)
+    _write_keypoints_h5(
+        h5_path,
+        scorer="John",
+        img_rel=("labeled-data", "test", "img000.png"),
+        bodyparts=("bodypart1", "bodypart2"),
+        values=[10.0, 20.0, 30.0, 40.0],
+    )
+    # The project config declares fewer bodyparts than the annotations hold.
+    _write_dlc_config(project, bodyparts=("bodypart1",))
+
+    viewer.open(str(labeled), plugin="napari-deeplabcut")
+    qtbot.waitUntil(lambda: any(isinstance(ly, Points) for ly in viewer.layers), timeout=10_000)
+
+    layer = _get_points_layer_with_data(viewer)
+    hdr = layer.metadata.get("header")
+    hdr = hdr if isinstance(hdr, DLCHeaderModel) else DLCHeaderModel.model_validate(hdr)
+    assert "bodypart2" in hdr.bodyparts, "Header was taken from config.yaml instead of the annotation file"
+
+    viewer.layers.selection.select_only(layer)
+    keypoint_controls._save_layers_dialog(selected=True)
+    qtbot.wait(300)
+
+    saved = _read_hdf_any_key(h5_path)
+    # Guards against a vacuous pass: an aborted save would leave the file untouched.
+    assert set(saved.columns.get_level_values("bodyparts")) == {"bodypart1", "bodypart2"}
+    assert np.isfinite(saved.to_numpy(dtype=float)).all(), "Save did not write both bodyparts back"
+
+
+@pytest.mark.usefixtures("qtbot")
+def test_opening_a_second_folder_does_not_change_the_first_layers_header(
+    viewer,
+    keypoint_controls,
+    qtbot,
+    tmp_path,
+) -> None:
+    """Opening another folder must never reduce an existing layer's keypoints.
+
+    Guards the planned config auto-population: a config discovered for the folder being
+    opened must not reach a layer that belongs to a different one. Without this, opening a
+    folder whose project declares fewer bodyparts would erase the others on the next save.
+    """
+    project_a = tmp_path / "projectA"
+    folder_a = _write_frames(project_a / "labeled-data" / "videoA", ("img000.png",))
+    _write_dlc_config(project_a, bodyparts=("bodypart1", "bodypart2"))
+    _write_keypoints_h5(
+        folder_a / "CollectedData_John.h5",
+        scorer="John",
+        img_rel=("labeled-data", "videoA", "img000.png"),
+        bodyparts=("bodypart1", "bodypart2"),
+        values=[10.0, 20.0, 30.0, 40.0],
+    )
+
+    project_b = tmp_path / "projectB"
+    folder_b = _write_frames(project_b / "labeled-data" / "videoB", ("img100.png",))
+    _write_dlc_config(project_b, bodyparts=("bodypart1",))
+
+    viewer.open(str(folder_a), plugin="napari-deeplabcut")
+    qtbot.waitUntil(lambda: any(isinstance(ly, Points) for ly in viewer.layers), timeout=10_000)
+    layer = _get_points_layer_with_data(viewer)
+
+    # The documented way to switch: clear the images, keep the annotation layer. Opening B
+    # with A's images still loaded is refused outright, which would make this test vacuous.
+    for image_layer in [ly for ly in viewer.layers if isinstance(ly, Image)]:
+        viewer.layers.remove(image_layer)
+    qtbot.wait(100)
+
+    viewer.open(str(folder_b), plugin="napari-deeplabcut")
+    qtbot.waitUntil(lambda: any(isinstance(ly, Image) for ly in viewer.layers), timeout=10_000)
+    qtbot.wait(300)
+
+    hdr = layer.metadata.get("header")
+    hdr = hdr if isinstance(hdr, DLCHeaderModel) else DLCHeaderModel.model_validate(hdr)
+    assert "bodypart2" in hdr.bodyparts, (
+        "Opening another folder reduced the keypoints of a layer belonging to the first one"
+    )
diff --git a/src/napari_deeplabcut/_tests/e2e/utils.py b/src/napari_deeplabcut/_tests/e2e/utils.py
index 9a9aa9e7..da181e0a 100644
--- a/src/napari_deeplabcut/_tests/e2e/utils.py
+++ b/src/napari_deeplabcut/_tests/e2e/utils.py
@@ -5,6 +5,7 @@
 import math
 import os
 from pathlib import Path
+from types import SimpleNamespace
 
 import numpy as np
 import pandas as pd
@@ -38,6 +39,37 @@ def _write_minimal_png(path: Path, *, shape=(64, 64, 3)) -> None:
     imsave(str(path), img, check_contrast=False)
 
 
+def _write_dlc_config(
+    project: Path,
+    *,
+    scorer: str = "John",
+    bodyparts=("bodypart1", "bodypart2"),
+    colormap: str = "viridis",
+) -> Path:
+    """Write a minimal DLC config.yaml at the project root."""
+    import yaml
+
+    project.mkdir(parents=True, exist_ok=True)
+    cfg = {
+        "scorer": scorer,
+        "bodyparts": list(bodyparts),
+        "dotsize": 8,
+        "pcutoff": 0.6,
+        "colormap": colormap,
+    }
+    config_path = project / "config.yaml"
+    config_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
+    return config_path
+
+
+def _write_frames(folder: Path, names: tuple[str, ...]) -> Path:
+    """Populate a labeled-data folder with tiny frames and return it."""
+    folder.mkdir(parents=True, exist_ok=True)
+    for name in names:
+        _write_minimal_png(folder / name)
+    return folder
+
+
 def _make_minimal_dlc_project(tmp_path: Path, *, bodyparts=("bodypart1", "bodypart2")):
     """
     Build a minimal DLC-like folder:
@@ -49,36 +81,16 @@ def _make_minimal_dlc_project(tmp_path: Path, *, bodyparts=("bodypart1", "bodypa
     ``bodyparts`` accepts non-string values so callers can build a project whose keypoint
     names are numeric in both config.yaml and the H5 column level.
     """
-    import yaml
-
     project = tmp_path / "project"
-    labeled = project / "labeled-data" / "test"
-    labeled.mkdir(parents=True, exist_ok=True)
-
-    img_rel = ("labeled-data", "test", "img000.png")
-    img_path = project / Path(*img_rel)
-    _write_minimal_png(img_path)
-
-    cfg = {
-        "scorer": "John",
-        "bodyparts": list(bodyparts),
-        "dotsize": 8,
-        "pcutoff": 0.6,
-        "colormap": "viridis",
-    }
-    config_path = project / "config.yaml"
-    config_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
-
-    cols = pd.MultiIndex.from_product(
-        [["John"], list(bodyparts), ["x", "y"]],
-        names=["scorer", "bodyparts", "coords"],
+    labeled = _write_frames(project / "labeled-data" / "test", ("img000.png",))
+    config_path = _write_dlc_config(project, bodyparts=bodyparts)
+
+    h5_path = _write_keypoints_h5(
+        labeled / "CollectedData_John.h5",
+        scorer="John",
+        img_rel=("labeled-data", "test", "img000.png"),
+        bodyparts=bodyparts,
     )
-    idx = pd.MultiIndex.from_tuples([img_rel])
-    df0 = pd.DataFrame([[10.0, 20.0, np.nan, np.nan]], index=idx, columns=cols)
-
-    h5_path = labeled / "CollectedData_John.h5"
-    df0.to_hdf(h5_path, key="df_with_missing", mode="w")
-    df0.to_csv(str(h5_path).replace(".h5", ".csv"))
 
     return project, config_path, labeled, h5_path
 
@@ -191,26 +203,78 @@ def _make_project_config_and_frames_no_gt(tmp_path: Path):
       project/labeled-data/test/img000.png
     No CollectedData*.h5 initially.
     """
-    import yaml
+    project = tmp_path / "project"
+    labeled = _write_frames(project / "labeled-data" / "test", ("img000.png",))
+    config_path = _write_dlc_config(project, colormap="magma")
 
+    return project, config_path, labeled
+
+
+def _make_project_with_two_labeled_folders(
+    tmp_path: Path,
+    *,
+    b_frames: tuple[str, ...] = ("imgB000.png", "imgB001.png", "imgB002.png"),
+):
+    """
+    Project with two labeled-data folders:
+
+      project/config.yaml
+      project/labeled-data/videoA/imgA000.png
+      project/labeled-data/videoA/CollectedData_John.h5   (bodypart1 labeled)
+      project/labeled-data/videoB/<b_frames>              (no annotations)
+
+    By default videoB's frame names do not overlap videoA's. Pass ``b_frames`` matching
+    videoA's names to build the basename-collision case instead.
+    """
     project = tmp_path / "project"
-    labeled = project / "labeled-data" / "test"
-    labeled.mkdir(parents=True, exist_ok=True)
+    folder_a = _write_frames(project / "labeled-data" / "videoA", ("imgA000.png",))
+    folder_b = _write_frames(project / "labeled-data" / "videoB", b_frames)
+    config_path = _write_dlc_config(project, colormap="magma")
+
+    gt_path = _write_keypoints_h5(
+        folder_a / "CollectedData_John.h5",
+        scorer="John",
+        img_rel=("labeled-data", "videoA", "imgA000.png"),
+    )
 
-    img_rel = ("labeled-data", "test", "img000.png")
-    _write_minimal_png(project / Path(*img_rel))
+    return project, config_path, folder_a, folder_b, gt_path
 
-    cfg = {
-        "scorer": "John",
-        "bodyparts": ["bodypart1", "bodypart2"],
-        "dotsize": 8,
-        "pcutoff": 0.6,
-        "colormap": "magma",
-    }
-    config_path = project / "config.yaml"
-    config_path.write_text(yaml.safe_dump(cfg), encoding="utf-8")
 
-    return project, config_path, labeled
+def _make_two_projects_sharing_a_video_name(tmp_path: Path):
+    """Two DLC projects whose dataset folders are named after the same video.
+
+      project-A/config.yaml, project-A/labeled-data/mouse1/{img000,img001}.png + GT
+      project-B/config.yaml, project-B/labeled-data/mouse1/{img000,img001}.png
+
+    DLC names dataset folders after the video stem and frames by fixed convention, so
+    this is what re-labelling the same footage in a fresh project looks like on disk:
+    every path component below the project root is identical between the two.
+    """
+    project_a = tmp_path / "project-A"
+    project_b = tmp_path / "project-B"
+    frames = ("img000.png", "img001.png")
+
+    folder_a = _write_frames(project_a / "labeled-data" / "mouse1", frames)
+    folder_b = _write_frames(project_b / "labeled-data" / "mouse1", frames)
+
+    config_a = _write_dlc_config(project_a, scorer="John")
+    config_b = _write_dlc_config(project_b, scorer="Jane")
+
+    gt_path = _write_keypoints_h5(
+        folder_a / "CollectedData_John.h5",
+        scorer="John",
+        img_rel=("labeled-data", "mouse1", "img000.png"),
+    )
+
+    return SimpleNamespace(
+        project_a=project_a,
+        project_b=project_b,
+        folder_a=folder_a,
+        folder_b=folder_b,
+        config_a=config_a,
+        config_b=config_b,
+        gt_path=gt_path,
+    )
 
 
 def _read_h5_keypoints(path: Path) -> pd.DataFrame:
diff --git a/src/napari_deeplabcut/_tests/test_reader.py b/src/napari_deeplabcut/_tests/test_reader.py
index 2e978166..e49c61d2 100644
--- a/src/napari_deeplabcut/_tests/test_reader.py
+++ b/src/napari_deeplabcut/_tests/test_reader.py
@@ -1,3 +1,5 @@
+from pathlib import Path
+
 import cv2
 import dask.array as da
 import numpy as np
@@ -379,6 +381,21 @@ def test_read_video_output(video_path):
     assert frame.dtype == np.uint8
 
 
+def test_read_video_keys_the_dataset_it_belongs_to(video_path):
+    """A video names the labeled-data folder beside it, so it must carry that folder's key.
+
+    Without it the lifecycle manager reads the video as a dataset of its own and warns that
+    the annotations already open do not match it.
+    """
+    from napari_deeplabcut.core.project_paths import resolve_dataset_folder
+
+    _data, params, _kind = read_video(video_path)[0]
+    md = params["metadata"]
+
+    assert md["dataset_folder"] == resolve_dataset_folder(md["root"])
+    assert Path(md["root"]).parent.name == "labeled-data"
+
+
 def test_get_video_reader_dispatch(video_path):
     assert _reader.get_video_reader(video_path) is not None
     assert is_video(str(video_path))
diff --git a/src/napari_deeplabcut/_widgets.py b/src/napari_deeplabcut/_widgets.py
index ca7ab912..a3124afa 100644
--- a/src/napari_deeplabcut/_widgets.py
+++ b/src/napari_deeplabcut/_widgets.py
@@ -129,6 +129,7 @@ def __init__(self, napari_viewer):
         self.layer_manager.set_placeholder_config_decision_provider(self)
         ## Hook up signals for layer lifecycle events as needed, e.g.:
         self.layer_manager.session_conflict_rejected.connect(self._on_session_conflict_detected)
+        self.layer_manager.layer_dataset_mismatch.connect(self._on_layer_dataset_mismatch)
         self.layer_manager.refresh_video_panel_requested.connect(self._refresh_video_panel_context)
         self.layer_manager.refresh_layer_status_requested.connect(self._refresh_layer_status_panel)
         self.layer_manager.video_widget_visibility_requested.connect(self._on_video_widget_visibility_requested)
@@ -422,6 +423,14 @@ def _on_session_conflict_detected(self, reason: str) -> None:
             QMessageBox.Ok,
         )
 
+    def _on_layer_dataset_mismatch(self, reason: str) -> None:
+        QMessageBox.warning(
+            self,
+            "A layer does not match the folder you opened:",
+            f"{reason}\n\n",
+            QMessageBox.Ok,
+        )
+
     def _show_debug_window(self) -> None:
         try:
             if self._debug_window is None:
diff --git a/src/napari_deeplabcut/config/models.py b/src/napari_deeplabcut/config/models.py
index 258fde10..f9f624f7 100644
--- a/src/napari_deeplabcut/config/models.py
+++ b/src/napari_deeplabcut/config/models.py
@@ -454,7 +454,7 @@ class IOProvenance(BaseModel):
     kind:
         Whether this layer is ground-truth or machine output.
     dataset_key:
-        HDF5 key used for the keypoints table (default: ``keypoints``).
+        HDF5 key used for the keypoints table (default: ``df_with_missing``).
     """
 
     # Keep minimal but resilient to future additions
@@ -559,6 +559,15 @@ class PointsMetadata(BaseModel):
     shape: tuple[int, ...] | None = None
     name: str | None = None
 
+    dataset_folder: str | None = Field(
+        default=None,
+        description=(
+            "Absolute folder this layer was read from, assigned once at read time and never "
+            "rewritten. Unlike root and paths, which are overwritten when a layer adopts a new "
+            "image context, this can be used to decide whether that adoption should happen. "
+        ),
+    )
+
     project: str | None = None
     header: DLCHeaderModel | None = None
     io: IOProvenance | None = None
diff --git a/src/napari_deeplabcut/core/io.py b/src/napari_deeplabcut/core/io.py
index 699e8234..96963226 100644
--- a/src/napari_deeplabcut/core/io.py
+++ b/src/napari_deeplabcut/core/io.py
@@ -69,6 +69,7 @@
     canonicalize_path,
     find_nearest_config,
     infer_dlc_project_from_points_meta,
+    resolve_dataset_folder,
 )
 from napari_deeplabcut.core.provenance import resolve_output_path_from_metadata, should_nan_clear_existing_for_save
 from napari_deeplabcut.utils.debug import log_timing
@@ -80,6 +81,13 @@
 # -----------------------------------------------------------------------------
 _SUPPORTED_SUFFIXES = {ext.lower() for ext in SUPPORTED_IMAGES}
 DLC_CANONICAL_H5_KEY = "df_with_missing"  # TODO use this key instead of str literal in all places
+
+# "keypoints" is a legacy key written by this package, not an arbitrary fallback.
+# `_writer.py` used `key="keypoints"` from 30f37ca (2022-05-12) through a686875
+# (2026-04-27), when the canonical key was adopted. DeepLabCut uses "df_with_missing".
+#
+# Projects labelled during that period may legitimately hold either key.
+# Keep this to preserve compatibility with labelling data produced by earlier versions.
 FALLBACK_H5_KEYS = ["keypoints"]
 
 # -----------------------------------------------------------------------------
@@ -247,6 +255,7 @@ def read_hdf_single(file: Path, *, kind: AnnotationKind | None = None) -> list[L
     )
     layer_props["name"] = file.stem
     layer_props["metadata"]["root"] = str(file.parent)
+    layer_props["metadata"]["dataset_folder"] = resolve_dataset_folder(file.parent)
     layer_props["metadata"]["name"] = layer_props["name"]
     layer_props["metadata"]["config_colormap"] = config_colormap
 
@@ -852,6 +861,7 @@ def _build_image_layer_kwargs(
     metadata = {
         "paths": [canonicalize_path(fp, 3) for fp in filepaths],
         "root": str(filepaths[0].parent),
+        "dataset_folder": resolve_dataset_folder(filepaths[0].parent),
     }
     if dlc_meta is not None:
         metadata["dlc"] = dlc_meta
@@ -1066,6 +1076,7 @@ def _read_block(start: int, stop: int):
         "name": filename,
         "metadata": {
             "root": root,
+            "dataset_folder": resolve_dataset_folder(root),
         },
     }
     if dlc_meta is not None:
diff --git a/src/napari_deeplabcut/core/layer_lifecycle/manager.py b/src/napari_deeplabcut/core/layer_lifecycle/manager.py
index 5fafa4a8..b19ca62c 100644
--- a/src/napari_deeplabcut/core/layer_lifecycle/manager.py
+++ b/src/napari_deeplabcut/core/layer_lifecycle/manager.py
@@ -6,11 +6,13 @@
 from enum import Enum
 from types import MethodType
 from typing import TYPE_CHECKING, Any
+from weakref import WeakKeyDictionary, WeakSet
 
 import numpy as np
 from napari.layers import Image, Layer, Points, Tracks
 from napari.utils.events import Event
 from napari.utils.history import update_save_history
+from napari.utils.notifications import show_warning
 from qtpy.QtCore import QObject, Signal
 
 from ...config.keybinds import install_points_layer_keybindings, install_viewer_keybindings
@@ -26,8 +28,8 @@
     sync_points_from_image,
     write_points_meta,
 )
-from ...core.project_paths import PathMatchPolicy
-from ...core.remap import remap_layer_data_by_paths
+from ...core.project_paths import PathMatchPolicy, is_same_dataset, resolve_dataset_folder
+from ...core.remap import AnnotationFramesMissingError, remap_layer_data_by_paths
 from ...napari_compat import install_add_wrapper, install_paste_patch, layer_key, unwrap
 from ...napari_compat.points_layer import make_paste_data
 from ...tracking.core.data import TRACKING_LAYER_METADATA_KEY, is_tracking_result_points_layer
@@ -96,6 +98,7 @@ class LayerLifecycleManager(QObject, OwnedTimersMixin):
 
     # Session management
     session_conflict_rejected = Signal(str)  # if a new DLC folder is loaded on top of the current one
+    layer_dataset_mismatch = Signal(str)  # if a layer could not follow the newly opened folder
 
     def __init__(self, viewer: napari.Viewer, *, parent: QObject | None = None) -> None:
         super().__init__(parent=parent)
@@ -109,8 +112,12 @@ def __init__(self, viewer: napari.Viewer, *, parent: QObject | None = None) -> N
         self._label_mode = keypoints.LabelMode.default()
         self._active_dlc_image_layer_id: int | None = None
         self._image_meta = ImageMetadata()
+        self._image_dataset_folder: str | None = None
         self._project_path: str | None = None
 
+        self._dataset_mismatch_warned: WeakKeyDictionary[Layer, set[str]] = WeakKeyDictionary()
+        self._locked_for_dataset_mismatch: WeakSet[Layer] = WeakSet()
+
         self._attached = False
         self.viewer_keybinds_installed = False
 
@@ -361,6 +368,203 @@ def can_accept_dlc_session_image(self, layer: Image) -> tuple[bool, str | None]:
             "please save and clear the current layers before loading the new labeled data folder.",
         )
 
+    def _belongs_to_current_dataset(self, layer_dataset_folder: str | None) -> bool:
+        """Return True if a layer may follow the image context now loaded.
+
+        A layer with no folder is unbound (a config placeholder, say) and adopts what is
+        open.
+        """
+        if layer_dataset_folder is None:
+            return True
+
+        return is_same_dataset(layer_dataset_folder, self._image_dataset_folder)
+
+    def _report_layer_left_on_previous_dataset(self, layer: Any) -> None:
+        """Report that a layer did not follow the newly opened folder."""
+        metadata = layer.metadata or {}
+        root = metadata.get("root")
+        dataset = str(root) if root else "its original folder"
+        target = self._image_dataset_folder or str(self._image_meta.root or "")
+        name = getattr(layer, "name", layer)
+
+        # Not `dataset_folder`: an unbound layer passes that check while its `root` names
+        # somewhere else entirely, and it is `root` that receives the save.
+        saves_elsewhere = bool(root) and not is_same_dataset(
+            resolve_dataset_folder(root), resolve_dataset_folder(target)
+        )
+
+        if not saves_elsewhere:
+            reason = (
+                f"'{name}' does not match the frames now in {target}.\n\n"
+                "The layer annotations are unchanged and still save to their original folder. "
+                "Due to the newly loaded dataset context, it cannot be safely edited and has been locked.\n\n"
+            )
+        else:
+            reason = (
+                f"'{name}' could not be matched to the frames in the folder that was opened.\n\n"
+                f"It will still save to:\n  {dataset}\n"
+                f"not:\n  {target}\n\n"
+                "Due to this, it cannot be safely edited and has been locked.\n\n"
+            )
+        reason += (
+            "To label the folder you just opened:\n"
+            f"  1. Save '{name}' if it has unsaved changes\n"
+            "  2. Clear all layers, including the images\n"
+            "  3. Open the folder again\n"
+            "  4. If it has no annotations yet, drop the project's config.yaml in to get a\n"
+            "     keypoints layer carrying the project's bodyparts\n\n"
+            "If you did not mean to open it, clear all layers and reopen the previous folder."
+        )
+
+        self._notify_dataset_mismatch(layer, reason)
+
+    def _notify_dataset_mismatch(self, layer: Any, reason: str) -> None:
+        """Report that a layer is out of step with the open folder, and lock it.
+
+        Frame association is positional, so an edit made on the frame on screen would be
+        stored against the frame holding that position in the layer's own `paths`.
+        `_unlock_for_current_dataset` reverses the lock.
+
+        The remap sweep revisits every non-Image layer on every qualifying insert, so
+        report only the first time a layer fails to follow a given folder.
+        """
+        self._lock_against_current_dataset(layer)
+
+        target = self._image_dataset_folder or str(self._image_meta.root or "")
+
+        warned = self._dataset_mismatch_warned.setdefault(unwrap(layer), set())
+        if target in warned:
+            logger.debug(
+                "Extra dataset-mismatch notification for layer=%r folder=%r",
+                getattr(layer, "name", layer),
+                target,
+            )
+            return
+
+        warned.add(target)
+        self.viewer.status = reason
+
+        # Off the insert stack: this runs inside a layer insertion, and the UI shows a modal.
+        self._single_shot_owned(0, lambda: self.layer_dataset_mismatch.emit(reason))
+
+    def _lock_against_current_dataset(self, layer: Any) -> None:
+        """Take editing away from `layer`, and record that we were the ones who did.
+
+        Only Points layers are locked: nothing else here is hand-edited frame by frame.
+        """
+        if not isinstance(unwrap(layer), Points):
+            return
+
+        if self._set_layer_editable(layer, False):
+            self._locked_for_dataset_mismatch.add(unwrap(layer))
+
+    def _unlock_for_current_dataset(self, layer: Any) -> None:
+        """Re-enable editing once a layer's frame indices match the open folder again.
+
+        Only undoes our own lock: a layer left non-editable by the user or by napari is
+        not ours to re-enable.
+        """
+        if unwrap(layer) not in self._locked_for_dataset_mismatch:
+            return
+
+        self._set_layer_editable(layer, True)
+        self._locked_for_dataset_mismatch.discard(unwrap(layer))
+
+    def _set_layer_editable(self, layer: Any, editable: bool) -> bool:
+        """Set `editable`, returning whether the layer is now in that state."""
+        try:
+            if getattr(layer, "editable", editable) is not editable:
+                layer.editable = editable
+                logger.debug(
+                    "Set editable=%s on layer=%r",
+                    editable,
+                    getattr(layer, "name", layer),
+                )
+            return True
+        except Exception:
+            logger.debug(
+                "Could not set editable=%s on layer=%r",
+                editable,
+                getattr(layer, "name", layer),
+                exc_info=True,
+            )
+            return False
+
+    def _may_follow_current_dataset(self, layer: Any) -> bool:
+        """Whether `layer` may take `root` or `paths` from the folder now open.
+
+        Every path that hands a layer image context should ask this. A layer from another
+        dataset keeps its own `root` and `paths` and is reported once per folder: giving
+        it this folder's paths would leave the two naming different datasets, so it would
+        save into one and be indexed against the other.
+
+        With no folder open there is nothing to follow.
+        """
+        if not (self._image_meta.root or self._image_meta.paths):
+            return True
+
+        metadata = layer.metadata or {}
+
+        if self._belongs_to_current_dataset(metadata.get("dataset_folder")):
+            return True
+
+        logger.warning(
+            "Layer %r belongs to %s, not to the folder just opened (%s); leaving it alone.",
+            getattr(layer, "name", str(layer)),
+            metadata.get("dataset_folder"),
+            self._image_dataset_folder,
+        )
+        self._report_layer_left_on_previous_dataset(layer)
+        return False
+
+    def _record_dataset_folder(self, layer: Any) -> None:
+        """Name the folder a layer just took its paths from, if it did not name one.
+
+        A config placeholder arrives with no `dataset_folder`, so `_belongs_to_current_dataset`
+        lets it follow what is currently open. Persisting the dataset key stops the next folder
+        with the same frame names from following as well.
+        """
+        metadata = layer.metadata
+        if metadata is None:
+            return
+
+        if metadata.get("dataset_folder") is None and self._image_dataset_folder is not None:
+            metadata["dataset_folder"] = self._image_dataset_folder
+
+    def _reject_reloaded_annotations(self, layer: Points) -> bool:
+        """Drop a second copy of an annotation file that is already loaded.
+
+        Opening a folder re-reads its h5, so opening one twice yields two layers on the
+        same file. Both then save to it, and whichever is saved last wins, silently.
+
+        Keyed on `source_h5` alone: it is the absolute file both layers came from, so a
+        GT and a machine h5 in one folder stay distinct, and a layer without one (a config
+        placeholder, a tracking result) is never matched.
+        """
+        source = (layer.metadata or {}).get("source_h5")
+        if not source:
+            return False
+
+        for managed, _store in self.iter_managed_points():
+            if unwrap(managed) is unwrap(layer):
+                continue
+            if (managed.metadata or {}).get("source_h5") != source:
+                continue
+
+            logger.warning(
+                "Annotations from %s are already loaded as %r; dropping the reloaded copy.",
+                source,
+                getattr(managed, "name", managed),
+            )
+            show_warning(
+                f"These annotations are already open as '{getattr(managed, 'name', managed)}'.\n"
+                "The second copy was closed so both cannot save over each other."
+            )
+            self._single_shot_owned(LAYER_REMOVAL_DELAY_MS, lambda ly=layer: self._remove_layer_if_present(ly))
+            return True
+
+        return False
+
     def _reject_conflicting_dlc_image_layer(self, layer: Image, reason: str) -> None:
         """Reject a conflicting DLC session image safely.
 
@@ -589,6 +793,13 @@ def _sync_points_layers_from_image_meta(self) -> None:
             if ly.metadata is None:
                 ly.metadata = {}
 
+            # This runs before the remap sweep, so it has to make the same call: a layer
+            # from another dataset must not be handed this folder's paths here either.
+            if not self._may_follow_current_dataset(ly):
+                continue
+
+            inherits_context = not ly.metadata.get("paths") and bool(self._image_meta.paths or self._image_meta.root)
+
             res = read_points_meta(ly, migrate_legacy=True, drop_controls=False, drop_header=False)
             if hasattr(res, "errors"):
                 logger.warning(
@@ -614,6 +825,10 @@ def _sync_points_layers_from_image_meta(self) -> None:
                     getattr(ly, "name", ly),
                     out,
                 )
+                continue
+
+            if inherits_context:
+                self._record_dataset_folder(ly)
 
     def _cache_project_path_from_image_layer(self, layer: Image) -> None:
         """Best-effort lifecycle-owned cache of project path from an image/video layer."""
@@ -646,6 +861,7 @@ def _setup_image_layer(self, layer: Image, index: int | None = None, *, reorder:
                 pass
 
         self._active_dlc_image_layer_id = layer_key(layer)
+        self._image_dataset_folder = md.get("dataset_folder") or resolve_dataset_folder(md.get("root"))
         context_changed = self._update_image_meta_from_layer(layer)
 
         if not self._project_path:
@@ -723,10 +939,17 @@ def _wire_points_layer(self, layer: Points) -> KeypointStore | None:
         if proj:
             self._project_path = proj
 
-        if not layer.metadata.get("root") and self._image_meta.root:
-            layer.metadata["root"] = self._image_meta.root
-        if not layer.metadata.get("paths") and self._image_meta.paths:
-            layer.metadata["paths"] = self._image_meta.paths
+        # Inherit only when the layer has no paths of its own, and only from a folder it may follow.
+        if self._may_follow_current_dataset(layer) and not layer.metadata.get("paths"):
+            inherited = False
+            if not layer.metadata.get("root") and self._image_meta.root:
+                layer.metadata["root"] = self._image_meta.root
+                inherited = True
+            if not layer.metadata.get("paths") and self._image_meta.paths:
+                layer.metadata["paths"] = self._image_meta.paths
+                inherited = True
+            if inherited:
+                self._record_dataset_folder(layer)
 
         if root := layer.metadata.get("root"):
             update_save_history(root)
@@ -793,6 +1016,9 @@ def _setup_points_layer(
 
             # KEEP_AS_SEPARATE_LAYER means continue normal setup below.
 
+        if self._reject_reloaded_annotations(layer):
+            return PointsInsertResult.SKIPPED
+
         store = self._wire_points_layer(layer)
         if store is None:
             return PointsInsertResult.SKIPPED
@@ -849,6 +1075,7 @@ def _handle_removed_layer(self, layer: Any) -> None:
                 if self._active_dlc_image_layer_id == layer_key(layer):
                     self._active_dlc_image_layer_id = None
                     self._image_meta = ImageMetadata()
+                    self._image_dataset_folder = None
                     self._project_path = None
 
                     paths = layer.metadata.get("paths")
@@ -878,18 +1105,32 @@ def _remap_frame_indices(self, layer: Any) -> None:
             md = layer.metadata
             old_paths = md.get("paths") or []
 
-            try:
-                safe_image_meta = self._image_meta.model_dump(exclude_none=True)
-                safe_image_meta.pop("paths", None)
-                layer.metadata.update(safe_image_meta)
-            except Exception:
-                logger.debug(
-                    "Failed to sync non-path image metadata for layer=%r",
-                    getattr(layer, "name", str(layer)),
-                    exc_info=True,
-                )
+            if not self._may_follow_current_dataset(layer):
+                return
+
+            def _adopt_image_context() -> None:
+                """Take root/shape/name from the image context, and bind the dataset.
+
+                Only safe alongside a `paths` update: a layer whose root names one dataset
+                while its paths name another saves into the first and is indexed against
+                the second.
+                """
+                try:
+                    safe_image_meta = self._image_meta.model_dump(exclude_none=True)
+                    safe_image_meta.pop("paths", None)
+                    layer.metadata.update(safe_image_meta)
+                    self._record_dataset_folder(layer)
+                    self._unlock_for_current_dataset(layer)
+                except Exception:
+                    logger.debug(
+                        "Failed to sync non-path image metadata for layer=%r",
+                        getattr(layer, "name", str(layer)),
+                        exc_info=True,
+                    )
 
             if not old_paths:
+                # Not yet bound to any dataset, so there is nothing to contradict.
+                _adopt_image_context()
                 logger.debug(
                     "Skipping remap for layer=%r: no existing layer metadata paths.",
                     getattr(layer, "name", str(layer)),
@@ -910,6 +1151,8 @@ def _remap_frame_indices(self, layer: Any) -> None:
                     int(np.nanmax(arr_before[:, time_col])) if arr_before.size else None,
                 )
 
+            # Matching on bare filenames is only meaningful once we know both sides are the
+            # same dataset; so extract_frames's fixed frame naming cannot make unrelated folders match.
             res = remap_layer_data_by_paths(
                 data=layer.data,
                 old_paths=old_paths,
@@ -932,10 +1175,21 @@ def _remap_frame_indices(self, layer: Any) -> None:
                 layer.data = res.data
 
             if res.accept_paths_update:
+                _adopt_image_context()
                 layer.metadata["paths"] = list(new_paths)
                 if isinstance(layer, Points):
                     mark_layer_presentation_changed(layer)
 
+            else:
+                # Either no overlap at all, or a match too ambiguous to trust
+                logger.warning(
+                    "Remap rejected for %s: %s Leaving it bound to %s.",
+                    getattr(layer, "name", str(layer)),
+                    res.message,
+                    md.get("root"),
+                )
+                self._report_layer_left_on_previous_dataset(layer)
+
             if res.depth_used is None:
                 logger.debug("Remap skipped for %s: %s", getattr(layer, "name", str(layer)), res.message)
             else:
@@ -948,6 +1202,30 @@ def _remap_frame_indices(self, layer: Any) -> None:
                     res.message,
                 )
 
+        except AnnotationFramesMissingError as exc:
+            stem = (layer.metadata or {}).get("source_h5_stem") or "CollectedData_<ScorerName>"
+            # Refused, not failed: the layer keeps its own paths and data, so a save still
+            # writes where its keypoints came from. Say so rather than degrade quietly.
+            logger.error(
+                "Refused to remap %s: %s",
+                getattr(layer, "name", str(layer)),
+                exc,
+            )
+            # Reloading the layer or reopening the folder raises this again, so the lock
+            # only lifts once the frame list and the annotation file agree. The message
+            # gives guidance since no in-plugin action clears it.
+            self._notify_dataset_mismatch(
+                layer,
+                f"'{getattr(layer, 'name', layer)}' — {exc}\n\n"
+                "Your annotation file is not modified. The layer has been locked for "
+                "editing: it is still indexed against the frame list it was loaded with, "
+                "so labelling it now would store keypoints against the wrong frames.\n\n"
+                "Restore the frame in the folder, or remove its row:\n"
+                f"  1. Delete the row for the missing frame in {stem}.csv\n"
+                '  2. Run deeplabcut.convertcsv2h5("/path/to/config.yaml")\n'
+                "  3. Reopen the folder",
+            )
+
         except Exception:
             logger.exception("Failed to remap frame indices for layer %s", getattr(layer, "name", str(layer)))
 
diff --git a/src/napari_deeplabcut/core/metadata.py b/src/napari_deeplabcut/core/metadata.py
index 916e3802..ae0ab318 100644
--- a/src/napari_deeplabcut/core/metadata.py
+++ b/src/napari_deeplabcut/core/metadata.py
@@ -20,53 +20,6 @@
 # -----------------------------------------------------------------------------
 # Inference
 # -----------------------------------------------------------------------------
-def _coerce_path(p: str | None) -> Path | None:
-    if not p:
-        return None
-    try:
-        return Path(p).expanduser().resolve()
-    except Exception:
-        return Path(p)
-
-
-def _is_dlc_dataset_root(p: Path) -> bool:
-    """
-    Heuristic: DLC dataset folder usually looks like:
-      <project>/labeled-data/<dataset_name>
-
-    True if path contains a 'labeled-data' segment AND is deeper than that folder.
-    """
-    parts = [s.lower() for s in p.parts]
-    if "labeled-data" not in parts:
-        return False
-    return parts[-1] != "labeled-data"
-
-
-def _paths_look_like_labeled_data(paths: list[str] | None) -> bool:
-    """
-    Check if any path strings contain 'labeled-data/<dataset>/'.
-    Works with canonicalized paths like 'labeled-data/test/img000.png'.
-    """
-    if not paths:
-        return False
-    for s in paths:
-        if isinstance(s, str) and "labeled-data" in s.replace("\\", "/").lower():
-            return True
-    return False
-
-
-def _looks_like_project_root(points_root: str | None, project: str | None) -> bool:
-    """
-    Root equals project root (config parent) => this is WRONG for saving GT.
-    """
-    if not points_root or not project:
-        return False
-    try:
-        return Path(points_root).expanduser().resolve() == Path(project).expanduser().resolve()
-    except Exception:
-        return points_root == project
-
-
 def build_io_provenance_dict(
     *,
     project_root: str | Path,
@@ -152,52 +105,25 @@ def merge_points_metadata(base: PointsMetadata, incoming: PointsMetadata) -> Poi
 # -----------------------------------------------------------------------------
 def sync_points_from_image(image_meta: ImageMetadata, points_meta: PointsMetadata) -> PointsMetadata:
     """
-    Ensure PointsMetadata contains required image-derived fields.
+    Fill image-derived fields that the Points layer does not have yet.
 
-    Robust DLC policy:
-    - If image root looks like a DLC dataset folder (…/labeled-data/<dataset>),
-      prefer it for points_meta.root even if points_meta.root is already set
-      but equals project root (config parent) or is not a dataset root.
+    Only seeds what is missing. A field already set on the layer is never rewritten here:
+    which dataset a layer belongs to is decided by its `dataset_folder`, and rewriting `root`
+    behind that decision is what let annotations follow the wrong folder.
+
+    A layer that already has `paths` is not given a `root` either: the two route saves
+    together and must name one dataset. Such a layer takes its `root` from
+    `_remap_frame_indices`, once the paths update is verified.
     """
     updated = points_meta.model_dump(mode="python")
 
-    # --- First: fill missing fields (existing behavior) ---
-    for key in ("root", "paths", "shape", "name"):
+    keys = ("shape", "name") if updated.get("paths") else ("root", "paths", "shape", "name")
+    for key in keys:
         if updated.get(key) in (None, "", []):
             value = getattr(image_meta, key, None)
             if value not in (None, "", []):
                 updated[key] = value
 
-    # --- Second: if we have dataset context, correct stale root ---
-    img_root_p = _coerce_path(getattr(image_meta, "root", None))
-    pts_root_p = _coerce_path(updated.get("root"))
-    project_p = _coerce_path(updated.get("project"))
-
-    # Determine if the image root is a DLC dataset directory
-    image_is_dataset = bool(img_root_p is not None and _is_dlc_dataset_root(img_root_p))
-
-    # Additional hint: sometimes image_meta.root might be missing, but paths show labeled-data
-    # (depends on readers / napari versions). Use that as secondary signal.
-    if not image_is_dataset:
-        if _paths_look_like_labeled_data(getattr(image_meta, "paths", None)):
-            # If image paths look like labeled-data/... and we have a root-like string,
-            # try to interpret image_meta.root anyway.
-            image_is_dataset = bool(img_root_p is not None and _is_dlc_dataset_root(img_root_p))
-
-    if image_is_dataset and img_root_p is not None:
-        # Override root if:
-        # - points root equals project root (typical config-first bug), OR
-        # - points root exists but isn't a dataset root.
-        should_override_root = False
-
-        if _looks_like_project_root(str(pts_root_p) if pts_root_p else None, str(project_p) if project_p else None):
-            should_override_root = True
-        elif pts_root_p is not None and not _is_dlc_dataset_root(pts_root_p):
-            should_override_root = True
-
-        if should_override_root:
-            updated["root"] = str(img_root_p)
-
     return PointsMetadata(**updated)
 
 
diff --git a/src/napari_deeplabcut/core/project_paths.py b/src/napari_deeplabcut/core/project_paths.py
index 4d3f97d6..f31e67ab 100644
--- a/src/napari_deeplabcut/core/project_paths.py
+++ b/src/napari_deeplabcut/core/project_paths.py
@@ -19,6 +19,7 @@
 from __future__ import annotations
 
 import logging
+import os
 from collections.abc import Iterable
 from enum import Enum
 from pathlib import Path, PureWindowsPath
@@ -91,6 +92,11 @@ class PathMatchPolicy(Enum):
     - Try matching with depth=3
     - If no overlap, try depth=2
     - If still no overlap, try depth=1
+
+    Depth=1 compares bare filenames, and DLC names are standard for extracted frames
+    (img000.png, img001.png, ...) in every dataset folder of every project, so a match
+    there does not inform about actual data provenance.
+    Use this only to realign frames within a dataset already known to be the same.
     """
 
     ORDERED_DEPTHS = "ordered_depths"
@@ -732,6 +738,52 @@ def infer_dlc_project_from_video_path(
 # -----------------------------------------------------------------------------
 # Lifecycle/session helpers
 # -----------------------------------------------------------------------------
+# TODO @C-Achard 2026-09-21: centralize dataset_folder/root/paths into one frozen DatasetBinding with a single accessor,
+# so a partially-set layer reads as unbound
+def resolve_dataset_folder(folder: str | Path | None) -> str | None:
+    """Stable identity of the dataset folder a layer was read from.
+
+    Assigned once at read time and never rewritten. ``root`` and ``paths`` cannot serve
+    this purpose: adopting a new image context overwrites them, so using them as evidence
+    for whether that adoption should happen is circular.
+
+    Note this is dataset-level, not project-level: `session_key_from_project_context`
+    resolves to the project root and so cannot tell two videos in one project apart.
+    """
+    if not folder:
+        return None
+
+    try:
+        return str(Path(folder).expanduser().resolve())
+    except Exception:
+        logger.debug("Could not resolve dataset folder %r", folder, exc_info=True)
+        return str(folder)
+
+
+def is_same_dataset(a: str | None, b: str | None) -> bool:
+    """Return True if two dataset keys name the same folder on disk.
+
+    The same folder reaches us under more than one spelling: differing case or separators
+    on Windows, and a mapped drive against the UNC path behind it.
+
+    The `samefile` fallback is a fix for a reported failure: DeepLabCut/DeepLabCut#3348
+    had one project folder appear as `Z:/...`, as
+    `\\\\storage.domain/...` and as `\\\\?\\Volume{GUID}/...`, and string comparison alone
+    left DLC unable to find its own models. Do not simplify this to equality.
+    """
+    if a is None or b is None:
+        return False
+
+    if os.path.normcase(a) == os.path.normcase(b):
+        return True
+
+    try:
+        return os.path.samefile(a, b)
+    except OSError:
+        logger.debug("Could not compare dataset folders %r and %r on disk", a, b, exc_info=True)
+        return False
+
+
 def session_key_from_project_context(ctx: DLCProjectContext | None) -> str | None:
     """
     Build a stable session key from the strongest available project context hint.
diff --git a/src/napari_deeplabcut/core/remap.py b/src/napari_deeplabcut/core/remap.py
index db5f5d37..0910b626 100644
--- a/src/napari_deeplabcut/core/remap.py
+++ b/src/napari_deeplabcut/core/remap.py
@@ -18,6 +18,18 @@
 _WARN_MAPPED_RATIO = 0.80  # Warn if mapping coverage of old paths is below this ratio (mapped / old).
 _SAMPLE_N = 5  # Number of examples to include in warnings about duplicate keys.
 
+# Prefix of the message carried by AnnotationFramesMissingError.
+LOST_ANNOTATED_FRAMES = "Annotated frames lost their path"
+
+
+class AnnotationFramesMissingError(RuntimeError):
+    """A layer holds keypoints on a frame the opened folder does not contain.
+
+    Frame association is positional, so re-keying the layer would move those keypoints
+    onto whichever path took their position, and the next save would write them there.
+    No correct mapping exists, so the remap refuses rather than guessing.
+    """
+
 
 @dataclass(frozen=True)
 class RemapResult:
@@ -57,6 +69,38 @@ class RemapResult:
     warnings: tuple[str, ...] = ()
 
 
+def _annotated_frames_without_a_path(
+    *,
+    data: Any,
+    time_col: int,
+    idx_map: Mapping[int, int],
+    n_old: int,
+) -> str | None:
+    """Warn about annotated frames whose old path did not survive the remap.
+
+    Unmapped indices are left unchanged by `_remap_array`, so such a frame keeps its
+    index while `paths` is replaced, and now refers to whatever path holds that position.
+    """
+    unmapped = set(range(n_old)) - set(idx_map)
+    if not unmapped:
+        return None
+
+    try:
+        annotated = sorted(unmapped & {int(t) for t in np.asarray(data)[:, time_col]})
+    except Exception:
+        logger.debug("Could not determine annotated frames for remap diagnostics", exc_info=True)
+        return None
+
+    if not annotated:
+        return None
+
+    return (
+        f"{LOST_ANNOTATED_FRAMES}: {len(annotated)} annotated frame(s) are no longer in the folder "
+        f"(frames {annotated[:_SAMPLE_N]}). Keypoints on them cannot be matched to the frames now "
+        f"open, and moving them would save annotations onto a frame they do not belong to."
+    )
+
+
 def _remap_array(values: np.ndarray, idx_map: Mapping[int, int]) -> np.ndarray:
     """
     Remap time indices in an array of indices.
@@ -283,8 +327,16 @@ def remap_layer_data_by_paths(
             False, False, False, False, None, 0, "No overlap between old and new paths; skipping remap.", None
         )
 
+    dup_old = _find_duplicates(old_keys)
+    dup_new = _find_duplicates(new_keys)
+    non_bijective = len(set(idx_map.values())) < len(idx_map)
+
+    # Bare filenames repeat across dataset folders, so equal key lists at depth=1 are no
+    # evidence that the two sides hold the same frames.
+    ambiguous_depth1 = depth == 1 and (bool(dup_old) or bool(dup_new) or non_bijective)
+
     # If ordering already matches, accept metadata paths update but no data remap needed.
-    if old_keys == new_keys:
+    if old_keys == new_keys and not ambiguous_depth1:
         return RemapResult(
             changed=False,
             applied=False,
@@ -298,8 +350,6 @@ def remap_layer_data_by_paths(
 
     warnings: list[str] = []
 
-    dup_old = _find_duplicates(old_keys)
-    dup_new = _find_duplicates(new_keys)
     if dup_old:
         examples = ", ".join(list(dup_old.keys())[:_SAMPLE_N])
         warnings.append(f"Duplicate canonical keys in old_paths at depth={depth} (examples: {examples}).")
@@ -316,7 +366,6 @@ def remap_layer_data_by_paths(
     if mapped_ratio < _WARN_MAPPED_RATIO:
         warnings.append(f"Low mapping coverage: {mapped_ratio:.2f} (mapped={len(idx_map)} of old={len(old_keys)}).")
 
-    non_bijective = len(set(idx_map.values())) < len(idx_map)
     if non_bijective:
         warnings.append("Non-bijective mapping detected (multiple old indices map to the same new index).")
 
@@ -324,7 +373,6 @@ def remap_layer_data_by_paths(
         logger.warning("Remap may be ambiguous/risky: %s", w)
 
     # Reject ambiguous basename-only remaps.
-    ambiguous_depth1 = depth == 1 and (bool(dup_old) or bool(dup_new) or non_bijective)
     if ambiguous_depth1:
         msg = "Rejected ambiguous depth=1 remap; keeping original frame indices and paths."
         logger.warning(msg)
@@ -340,6 +388,14 @@ def remap_layer_data_by_paths(
             warnings=tuple(warnings),
         )
 
+    lost = _annotated_frames_without_a_path(data=data, time_col=time_col, idx_map=idx_map, n_old=len(old_keys))
+    if lost:
+        logger.warning(lost)
+        warnings.append(lost)
+        # Re-keying the layer would move these rows onto whichever path took their
+        # position, and the next save would write them there.
+        raise AnnotationFramesMissingError(lost)
+
     res = remap_time_indices(data=data, time_col=time_col, idx_map=idx_map)
 
     return RemapResult(