diff --git a/ami/base/permissions.py b/ami/base/permissions.py
index 328aa8384..efe444662 100644
--- a/ami/base/permissions.py
+++ b/ami/base/permissions.py
@@ -172,6 +172,24 @@ def has_object_permission(self, request, view, obj: BaseModel):
         return obj.check_permission(request.user, view.action)
 
 
+TRACKING_NOT_ENABLED_MESSAGE = "Tracking is not enabled for this project."
+
+
+class TrackingEnabled(permissions.BasePermission):
+    """
+    Refuse an action on an object whose project has not opted into tracking.
+
+    Pair it after ObjectPermission, so a user without rights on the object gets the
+    usual refusal rather than a hint about the project's settings.
+    """
+
+    message = TRACKING_NOT_ENABLED_MESSAGE
+
+    def has_object_permission(self, request, view, obj: BaseModel):
+        project = obj.get_project() if hasattr(obj, "get_project") else None
+        return bool(project and project.feature_flags.tracking)
+
+
 class ProjectPipelineConfigPermission(ObjectPermission):
     """
     Permission for the nested project pipelines route (/projects/{pk}/pipelines/).
diff --git a/ami/exports/base.py b/ami/exports/base.py
index 389480d5e..7a5c25bbf 100644
--- a/ami/exports/base.py
+++ b/ami/exports/base.py
@@ -11,6 +11,8 @@ class BaseExporter(ABC):
     """Base class for all data export handlers."""
 
     file_format = ""  # To be defined in child classes
+    # A project feature flag that must be on before this format can be requested.
+    required_feature_flag: str | None = None
     serializer_class = None
     filter_backends = []
 
diff --git a/ami/exports/format_types.py b/ami/exports/format_types.py
index a3f4c82d0..b7542e013 100644
--- a/ami/exports/format_types.py
+++ b/ami/exports/format_types.py
@@ -15,10 +15,19 @@
 
 
 def get_export_serializer():
-    from ami.main.api.serializers import OccurrenceSerializer
+    from ami.main.api.serializers import DetectionNestedSerializer, OccurrenceSerializer
+
+    # The detail response pages its detections; an export carries every one of them.
+    detail_only_fields = ("grouping_summary", "first_detection", "last_detection")
 
     class OccurrenceExportSerializer(OccurrenceSerializer):
         detection_images = serializers.SerializerMethodField()
+        detections = DetectionNestedSerializer(many=True, read_only=True)
+
+        class Meta(OccurrenceSerializer.Meta):
+            # The grouping summary describes the detections as they stand at read
+            # time; it is not part of the occurrence record and is never exported.
+            fields = [name for name in OccurrenceSerializer.Meta.fields if name not in detail_only_fields]
 
         def get_detection_images(self, obj: Occurrence):
             """Convert the generator field to a list before serialization"""
@@ -110,6 +119,10 @@ class OccurrenceTabularSerializer(serializers.ModelSerializer):
     agreed_with_user = serializers.SerializerMethodField()
     determination_matches_machine_prediction = serializers.SerializerMethodField()
 
+    # Track grouping confirmation; who confirmed it is user data and is not exported.
+    grouping_verified = serializers.BooleanField(read_only=True)
+    grouping_verified_at = serializers.DateTimeField(allow_null=True, read_only=True)
+
     # Detection fields
     best_detection_url = serializers.SerializerMethodField()
     best_detection_bbox = serializers.SerializerMethodField()
@@ -139,6 +152,8 @@ class Meta:
             "agreed_with_algorithm",
             "agreed_with_user",
             "determination_matches_machine_prediction",
+            "grouping_verified",
+            "grouping_verified_at",
             "detections_count",
             "first_appearance_timestamp",
             "last_appearance_timestamp",
@@ -252,3 +267,25 @@ def export(self):
                 self.update_job_progress(records_exported)
         self.update_export_stats(file_temp_path=temp_file.name)
         return temp_file.name  # Return the file path
+
+
+class TracksCSVExporter(BaseExporter):
+    """One row per detection of every occurrence in scope; see ami/exports/tracks.py for the columns."""
+
+    file_format = "csv"
+    required_feature_flag = "tracking"
+
+    def get_queryset(self):
+        return Occurrence.objects.with_real_detections().filter(project=self.project)  # type: ignore[union-attr]
+
+    def export(self):
+        from ami.exports.tracks import write_tracks_csv
+
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode="w", newline="", encoding="utf-8")
+        with open(temp_file.name, "w", newline="", encoding="utf-8") as csvfile:
+            rows = write_tracks_csv(self.queryset, csvfile, on_chunk=self.update_job_progress)
+        self.update_export_stats(file_temp_path=temp_file.name)
+        # A tracks file holds one record per detection, not per occurrence.
+        self.data_export.record_count = rows
+        self.data_export.save(update_fields=["record_count"])
+        return temp_file.name
diff --git a/ami/exports/migrations/0002_add_tracks_csv_format.py b/ami/exports/migrations/0002_add_tracks_csv_format.py
new file mode 100644
index 000000000..e2af0d8e3
--- /dev/null
+++ b/ami/exports/migrations/0002_add_tracks_csv_format.py
@@ -0,0 +1,24 @@
+# Generated by Django 4.2.10 on 2026-09-22 17:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("exports", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="dataexport",
+            name="format",
+            field=models.CharField(
+                choices=[
+                    ("occurrences_api_json", "occurrences_api_json"),
+                    ("occurrences_simple_csv", "occurrences_simple_csv"),
+                    ("tracks_csv", "tracks_csv"),
+                ],
+                max_length=255,
+            ),
+        ),
+    ]
diff --git a/ami/exports/registry.py b/ami/exports/registry.py
index 29a4cc0e7..8574c77c6 100644
--- a/ami/exports/registry.py
+++ b/ami/exports/registry.py
@@ -27,3 +27,4 @@ def get_supported_formats(cls):
 
 ExportRegistry.register("occurrences_api_json")(format_types.JSONExporter)
 ExportRegistry.register("occurrences_simple_csv")(format_types.CSVExporter)
+ExportRegistry.register("tracks_csv")(format_types.TracksCSVExporter)
diff --git a/ami/exports/serializers.py b/ami/exports/serializers.py
index e16f63025..3574e7cb1 100644
--- a/ami/exports/serializers.py
+++ b/ami/exports/serializers.py
@@ -62,6 +62,17 @@ def validate_format(self, value):
             raise serializers.ValidationError(f"Invalid format. Supported formats are: {supported_formats}")
         return value
 
+    def validate(self, attrs):
+        attrs = super().validate(attrs)
+        exporter = ExportRegistry.get_exporter(attrs.get("format"))
+        flag = getattr(exporter, "required_feature_flag", None)
+        project = attrs.get("project")
+        if flag and project is not None and not getattr(project.feature_flags, flag, False):
+            raise serializers.ValidationError(
+                {"format": f"The {attrs['format']} export needs the {flag} feature, which is off for this project."}
+            )
+        return attrs
+
     def get_file_url(self, obj):
         return obj.get_absolute_url(request=self.context.get("request"))
 
diff --git a/ami/exports/tests.py b/ami/exports/tests.py
index 866b1af61..3a8e6502f 100644
--- a/ami/exports/tests.py
+++ b/ami/exports/tests.py
@@ -1,6 +1,8 @@
 import csv
+import io
 import json
 import logging
+from unittest import mock
 
 from django.core.files.base import ContentFile
 from django.core.files.storage import default_storage
@@ -551,3 +553,262 @@ def test_csv_has_all_new_fields(self):
         ]
         for field in expected_fields:
             self.assertIn(field, headers, f"Missing CSV field: {field}")
+
+
+class TracksExportTest(TestCase):
+    """The tracks CSV: one row per detection, a fixed column contract, and bounded queries."""
+
+    EXPECTED_HEADER = (
+        "occurrence_id,detection_id,event_id,deployment_id,source_image_id,timestamp,frame_index,frame_count,"
+        "bbox_x1,bbox_y1,bbox_x2,bbox_y2,image_width,image_height,detection_label,detection_score,"
+        "occurrence_determination,occurrence_determination_score,grouping_verified,grouping_verified_at,"
+        "has_feature_vector,next_detection_id"
+    )
+
+    def setUp(self):
+        self.project, self.deployment = setup_test_project(reuse=False)
+        self.user = self.project.owner
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=3, interval_minutes=1)
+        group_images_into_events(self.deployment)
+        create_taxa(self.project)
+        self.taxon = Taxon.objects.filter(projects=self.project).first()
+        self.algorithm, _ = Algorithm.objects.get_or_create(
+            name="test-classifier", defaults={"key": "test-classifier"}
+        )
+        self.captures = list(self.project.captures.order_by("timestamp"))
+        self.captures[0].width, self.captures[0].height = 4096, 2160
+        self.captures[0].save()
+        # Three occurrences of three detections each, created latest frame first so that
+        # the export cannot get frame order from detection pks.
+        self.occurrences = [self._make_track(offset=i * 100) for i in range(3)]
+
+    def _make_track(self, offset: int) -> Occurrence:
+        occurrence = Occurrence.objects.create(
+            project=self.project,
+            deployment=self.deployment,
+            event=self.captures[0].event,
+            determination=self.taxon,
+            determination_score=0.9,
+        )
+        for capture in reversed(self.captures):
+            detection = Detection.objects.create(
+                source_image=capture,
+                timestamp=capture.timestamp,
+                bbox=[offset, offset, offset + 10, offset + 20],
+                occurrence=occurrence,
+            )
+            detection.classifications.create(
+                taxon=self.taxon, score=0.8, timestamp=capture.timestamp, algorithm=self.algorithm, terminal=True
+            )
+        return occurrence
+
+    def _rows(self, occurrences=None, **kwargs) -> list[dict[str, str]]:
+        from ami.exports.tracks import iter_track_rows
+
+        return list(iter_track_rows(occurrences or Occurrence.objects.filter(project=self.project), **kwargs))
+
+    def _run_format_export(self) -> tuple[str, DataExport]:
+        data_export = DataExport.objects.create(user=self.user, project=self.project, format="tracks_csv")
+        file_path = data_export.run_export().replace("/media/", "")
+        with default_storage.open(file_path, "r") as f:
+            content = f.read()
+        default_storage.delete(file_path)
+        data_export.refresh_from_db()
+        return content, data_export
+
+    def _request_export(self):
+        client = APIClient()
+        client.force_authenticate(user=self.user)
+        with mock.patch("ami.jobs.models.Job.enqueue"):
+            return client.post(
+                f"/api/v2/exports/?project_id={self.project.pk}",
+                {"project": self.project.pk, "format": "tracks_csv"},
+                format="json",
+            )
+
+    def test_tracks_export_is_refused_while_tracking_is_off(self):
+        self.assertFalse(self.project.feature_flags.tracking)
+        response = self._request_export()
+        self.assertEqual(response.status_code, 400, response.data)
+        self.assertIn("format", response.data)
+        self.assertFalse(DataExport.objects.filter(project=self.project, format="tracks_csv").exists())
+
+    def test_tracks_export_is_accepted_once_tracking_is_on(self):
+        self.project.feature_flags.tracking = True
+        self.project.save(update_fields=["feature_flags"])
+        response = self._request_export()
+        self.assertEqual(response.status_code, 201, response.data)
+
+    def test_format_export_header_is_the_contract(self):
+        content, data_export = self._run_format_export()
+        lines = content.splitlines()
+        self.assertEqual(lines[0], self.EXPECTED_HEADER)
+        self.assertEqual(len(lines) - 1, 9)
+        self.assertEqual(data_export.record_count, 9, "A tracks export counts detection rows")
+
+    def test_frame_index_follows_capture_time(self):
+        rows = [row for row in self._rows() if row["occurrence_id"] == str(self.occurrences[0].pk)]
+        by_capture = {int(row["source_image_id"]): row for row in rows}
+        for index, capture in enumerate(self.captures):
+            row = by_capture[capture.pk]
+            self.assertEqual(row["frame_index"], str(index))
+            self.assertEqual(row["frame_count"], "3")
+            self.assertEqual(row["timestamp"], capture.timestamp.isoformat())
+        first = by_capture[self.captures[0].pk]
+        self.assertEqual((first["image_width"], first["image_height"]), ("4096", "2160"))
+        self.assertEqual((first["bbox_x1"], first["bbox_y2"]), ("0", "20"))
+        self.assertEqual((first["detection_label"], first["detection_score"]), (self.taxon.name, "0.8"))
+        self.assertEqual(by_capture[self.captures[1].pk]["image_width"], "")
+
+    def test_grouping_verified_flag(self):
+        from django.utils import timezone
+
+        verified = self.occurrences[1]
+        verified.grouping_verified_at = timezone.now()
+        verified.save(update_fields=["grouping_verified_at"])
+
+        rows = self._rows()
+        flags = {row["occurrence_id"]: (row["grouping_verified"], row["grouping_verified_at"]) for row in rows}
+        self.assertEqual(flags[str(verified.pk)], ("true", verified.grouping_verified_at.isoformat()))
+        self.assertEqual(flags[str(self.occurrences[0].pk)], ("false", ""))
+
+    def test_feature_vector_and_next_detection(self):
+        from ami.tests.fixtures.tracking import pgvector_is_available
+
+        detections = list(self.occurrences[0].detections.order_by("source_image__timestamp"))
+        detections[0].next_detection = detections[1]
+        detections[0].save(update_fields=["next_detection"])
+        if pgvector_is_available():
+            detections[0].classifications.update(features_2048=[0.1] * 2048)
+
+        rows = {int(row["detection_id"]): row for row in self._rows()}
+        self.assertEqual(rows[detections[0].pk]["next_detection_id"], str(detections[1].pk))
+        self.assertEqual(rows[detections[1].pk]["next_detection_id"], "")
+        self.assertEqual(rows[detections[1].pk]["has_feature_vector"], "false")
+        if pgvector_is_available():
+            self.assertEqual(rows[detections[0].pk]["has_feature_vector"], "true")
+
+    def test_query_count_is_one_pair_per_chunk(self):
+        from django.db import connection
+        from django.test.utils import CaptureQueriesContext
+
+        from ami.main.tests import cachalot_disabled
+
+        # Three occurrences in chunks of two: occurrences, detections, occurrences, detections.
+        with cachalot_disabled(), CaptureQueriesContext(connection) as ctx:
+            rows = self._rows(chunk_size=2)
+        self.assertEqual(len(rows), 9)
+        self.assertEqual(len(ctx.captured_queries), 4)
+
+        # Doubling the detections per occurrence adds no queries.
+        for occurrence in self.occurrences:
+            for detection in list(occurrence.detections.all()):
+                detection.pk = None
+                detection.next_detection = None
+                detection.save()
+        with cachalot_disabled(), CaptureQueriesContext(connection) as ctx:
+            rows = self._rows(chunk_size=2)
+        self.assertEqual(len(rows), 18)
+        self.assertEqual(len(ctx.captured_queries), 4)
+
+    def _run_command(self, **options) -> tuple[list[dict[str, str]], str]:
+        import io
+
+        from django.core.management import call_command
+
+        stdout, stderr = io.StringIO(), io.StringIO()
+        call_command("export_tracks", project=self.project.pk, stdout=stdout, stderr=stderr, **options)
+        lines = stdout.getvalue().splitlines()
+        self.assertEqual(lines[0], self.EXPECTED_HEADER)
+        return list(csv.DictReader(lines)), stderr.getvalue()
+
+    def test_management_command_writes_the_same_csv(self):
+        rows, summary = self._run_command()
+        self.assertEqual(len(rows), 9)
+        self.assertIn("Wrote 9 detection rows", summary)
+
+    def test_management_command_event_filter(self):
+        import datetime
+
+        from ami.main.models import Event
+
+        first_event = self.captures[0].event
+        other_event = Event.objects.create(
+            project=self.project,
+            deployment=self.deployment,
+            group_by="2030-01-01",
+            start=datetime.datetime(2030, 1, 1, 22, 0),
+        )
+        moved = self.occurrences[2]
+        moved.event = other_event
+        moved.save(update_fields=["event"])
+
+        rows, _ = self._run_command(events=[first_event.pk])
+        self.assertEqual(
+            {row["occurrence_id"] for row in rows}, {str(self.occurrences[0].pk), str(self.occurrences[1].pk)}
+        )
+        self.assertEqual(len(rows), 6)
+
+        rows, _ = self._run_command(events=[first_event.pk, other_event.pk])
+        self.assertEqual({row["occurrence_id"] for row in rows}, {str(o.pk) for o in self.occurrences})
+        self.assertEqual(len(rows), 9)
+
+    def test_management_command_verified_only(self):
+        from django.utils import timezone
+
+        rows, _ = self._run_command(verified_only=True)
+        self.assertEqual(rows, [], "No confirmed tracks yet, so only the header comes out")
+
+        verified = self.occurrences[1]
+        verified.grouping_verified_at = timezone.now()
+        verified.save(update_fields=["grouping_verified_at"])
+        rows, _ = self._run_command(verified_only=True)
+        self.assertEqual({row["occurrence_id"] for row in rows}, {str(verified.pk)})
+        self.assertEqual(len(rows), 3)
+        self.assertEqual({row["grouping_verified"] for row in rows}, {"true"})
+
+    def test_undetermined_tracks_are_exported_and_scored_alike(self):
+        """On a project where only a detector ran, no occurrence has a determination, and its
+        confirmed tracks must still reach the benchmark file that the scorer reads them from."""
+        from django.core.management import call_command
+        from django.utils import timezone
+
+        undetermined = Occurrence.objects.create(
+            project=self.project, deployment=self.deployment, event=self.captures[0].event
+        )
+        for capture in self.captures:
+            Detection.objects.create(
+                source_image=capture, timestamp=capture.timestamp, bbox=[500, 500, 510, 520], occurrence=undetermined
+            )
+        self.assertIsNone(Occurrence.objects.get(pk=undetermined.pk).determination_id)
+        Occurrence.objects.filter(pk__in=[undetermined.pk, self.occurrences[0].pk]).update(
+            grouping_verified_at=timezone.now()
+        )
+
+        content, _ = self._run_format_export()
+        exported = {row["occurrence_id"] for row in csv.DictReader(content.splitlines())}
+        self.assertIn(str(undetermined.pk), exported)
+
+        rows, _ = self._run_command(verified_only=True)
+        self.assertEqual({row["occurrence_id"] for row in rows}, {str(undetermined.pk), str(self.occurrences[0].pk)})
+        output = io.StringIO()
+        args = ["--project", str(self.project.pk), "--format", "json", "--no-require-features"]
+        call_command("evaluate_tracking", *args, stdout=output)
+        self.assertEqual(len(rows), json.loads(output.getvalue())["overall"]["detections"])
+
+    def test_occurrence_csv_carries_grouping_confirmation(self):
+        from django.utils import timezone
+
+        verified = self.occurrences[0]
+        verified.grouping_verified_at = timezone.now()
+        verified.save(update_fields=["grouping_verified_at"])
+        data_export = DataExport.objects.create(user=self.user, project=self.project, format="occurrences_simple_csv")
+        file_path = data_export.run_export().replace("/media/", "")
+        with default_storage.open(file_path, "r") as f:
+            rows = {row["id"]: row for row in csv.DictReader(f)}
+        default_storage.delete(file_path)
+        self.assertNotIn("grouping_verified_by", next(iter(rows.values())))
+        self.assertEqual(rows[str(verified.pk)]["grouping_verified"], "True")
+        self.assertTrue(rows[str(verified.pk)]["grouping_verified_at"])
+        self.assertEqual(rows[str(self.occurrences[1].pk)]["grouping_verified"], "False")
+        self.assertEqual(rows[str(self.occurrences[1].pk)]["grouping_verified_at"], "")
diff --git a/ami/exports/tracks.py b/ami/exports/tracks.py
new file mode 100644
index 000000000..76150c2ef
--- /dev/null
+++ b/ami/exports/tracks.py
@@ -0,0 +1,174 @@
+"""
+One row per detection of every occurrence (track) in scope, for taking tracks out as a benchmark.
+
+The export format and the ``export_tracks`` management command both write through
+``iter_track_rows()``, so ``TRACKS_CSV_COLUMNS`` is the single definition of the columns.
+No user data is exported: a confirmed grouping carries its time, not who confirmed it.
+"""
+
+import csv
+import datetime
+import typing
+from collections.abc import Callable, Iterator
+
+from django.db import models
+from django.db.models import Exists, OuterRef, Subquery
+
+from ami.main.models import BEST_MACHINE_PREDICTION_ORDER, Classification, Detection, Occurrence
+from ami.main.models_future.tracks import CAPTURE_ORDER
+
+TRACKS_CSV_COLUMNS: typing.Final = (
+    "occurrence_id",
+    "detection_id",
+    "event_id",
+    "deployment_id",
+    "source_image_id",
+    "timestamp",
+    "frame_index",
+    "frame_count",
+    "bbox_x1",
+    "bbox_y1",
+    "bbox_x2",
+    "bbox_y2",
+    "image_width",
+    "image_height",
+    "detection_label",
+    "detection_score",
+    "occurrence_determination",
+    "occurrence_determination_score",
+    "grouping_verified",
+    "grouping_verified_at",
+    "has_feature_vector",
+    "next_detection_id",
+)
+
+DEFAULT_CHUNK_SIZE: typing.Final = 500
+
+
+def _cell(value) -> str:
+    """Render one value the way every tracks CSV writes it: blank for None, lowercase booleans."""
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, datetime.datetime):
+        return value.isoformat()
+    return str(value)
+
+
+def _detections_for(occurrence_ids: list[int]) -> models.QuerySet:
+    """Real detections of the given occurrences, in frame order, with their own best label."""
+    best_classification = Classification.objects.filter(detection=OuterRef("pk")).order_by(
+        *BEST_MACHINE_PREDICTION_ORDER
+    )
+    return (
+        Detection.objects.valid()  # type: ignore[attr-defined]  Custom queryset method
+        .filter(occurrence_id__in=occurrence_ids)
+        .annotate(
+            label=Subquery(best_classification.values("taxon__name")[:1]),
+            label_score=Subquery(best_classification.values("score")[:1]),
+            # Same notion as ClassificationQuerySet.with_has_features(), per detection.
+            has_feature_vector=Exists(
+                Classification.objects.filter(detection=OuterRef("pk"), features_2048__isnull=False)
+            ),
+        )
+        .order_by("occurrence_id", *CAPTURE_ORDER)
+        .values(
+            "pk",
+            "occurrence_id",
+            "bbox",
+            "next_detection_id",
+            "source_image_id",
+            "source_image__timestamp",
+            "source_image__width",
+            "source_image__height",
+            "source_image__event_id",
+            "source_image__deployment_id",
+            "label",
+            "label_score",
+            "has_feature_vector",
+        )
+    )
+
+
+def iter_track_rows(
+    occurrences: models.QuerySet[Occurrence],
+    chunk_size: int = DEFAULT_CHUNK_SIZE,
+    on_chunk: Callable[[int], None] | None = None,
+) -> Iterator[dict[str, str]]:
+    """
+    Yield one row per detection of each occurrence in ``occurrences``, keyed by TRACKS_CSV_COLUMNS.
+
+    Occurrences are read in pk order, ``chunk_size`` at a time, with one detection query per
+    chunk, so the query count grows with the number of chunks and never with the rows.
+    ``on_chunk`` receives the running count of occurrences read, for progress reporting.
+    """
+    scope = (
+        occurrences.order_by("pk")
+        .values("pk", "determination__name", "determination_score", "grouping_verified_at")
+        .distinct()  # A capture-set filter joins through detections and repeats occurrences.
+    )
+    occurrences_read = 0
+    last_pk = 0
+    while True:
+        chunk = list(scope.filter(pk__gt=last_pk)[:chunk_size])
+        if not chunk:
+            break
+        last_pk = chunk[-1]["pk"]
+        occurrences_read += len(chunk)
+
+        detections_by_occurrence: dict[int, list[dict]] = {}
+        for detection in _detections_for([row["pk"] for row in chunk]):
+            detections_by_occurrence.setdefault(detection["occurrence_id"], []).append(detection)
+
+        for occurrence in chunk:
+            detections = detections_by_occurrence.get(occurrence["pk"], [])
+            verified_at = occurrence["grouping_verified_at"]
+            for frame_index, detection in enumerate(detections):
+                bbox = detection["bbox"]
+                x1, y1, x2, y2 = bbox if isinstance(bbox, list) and len(bbox) == 4 else (None,) * 4
+                yield {
+                    "occurrence_id": _cell(occurrence["pk"]),
+                    "detection_id": _cell(detection["pk"]),
+                    "event_id": _cell(detection["source_image__event_id"]),
+                    "deployment_id": _cell(detection["source_image__deployment_id"]),
+                    "source_image_id": _cell(detection["source_image_id"]),
+                    "timestamp": _cell(detection["source_image__timestamp"]),
+                    "frame_index": _cell(frame_index),
+                    "frame_count": _cell(len(detections)),
+                    "bbox_x1": _cell(x1),
+                    "bbox_y1": _cell(y1),
+                    "bbox_x2": _cell(x2),
+                    "bbox_y2": _cell(y2),
+                    "image_width": _cell(detection["source_image__width"]),
+                    "image_height": _cell(detection["source_image__height"]),
+                    "detection_label": _cell(detection["label"]),
+                    "detection_score": _cell(detection["label_score"]),
+                    "occurrence_determination": _cell(occurrence["determination__name"]),
+                    "occurrence_determination_score": _cell(occurrence["determination_score"]),
+                    "grouping_verified": _cell(verified_at is not None),
+                    "grouping_verified_at": _cell(verified_at),
+                    "has_feature_vector": _cell(detection["has_feature_vector"]),
+                    "next_detection_id": _cell(detection["next_detection_id"]),
+                }
+
+        if on_chunk:
+            on_chunk(occurrences_read)
+        if len(chunk) < chunk_size:
+            break
+
+
+def write_tracks_csv(
+    occurrences: models.QuerySet[Occurrence],
+    stream: typing.TextIO,
+    chunk_size: int = DEFAULT_CHUNK_SIZE,
+    on_chunk: Callable[[int], None] | None = None,
+) -> int:
+    """Write the header and every track row to ``stream``; return the number of detection rows."""
+    writer = csv.DictWriter(stream, fieldnames=TRACKS_CSV_COLUMNS)
+    writer.writeheader()
+    rows = 0
+    for row in iter_track_rows(occurrences, chunk_size=chunk_size, on_chunk=on_chunk):
+        writer.writerow(row)
+        rows += 1
+    return rows
diff --git a/ami/jobs/models.py b/ami/jobs/models.py
index ff65f31f2..791677e1c 100644
--- a/ami/jobs/models.py
+++ b/ami/jobs/models.py
@@ -19,7 +19,12 @@
 from ami.jobs.tasks import cleanup_async_job_if_needed, run_job
 from ami.main.models import Deployment, Project, SourceImage, SourceImageCollection
 from ami.ml.models import Pipeline
-from ami.ml.post_processing.registry import get_postprocessing_task
+from ami.ml.post_processing.registry import (
+    MEMBER_POST_PROCESSING_TASKS,
+    get_postprocessing_task,
+    staff_only_config_fields,
+)
+from ami.ml.post_processing.tracking_task import TrackingTask
 from ami.utils.schemas import OrderedEnum
 
 logger = logging.getLogger(__name__)
@@ -572,7 +577,7 @@ def process_images(cls, job, images):
         total_classifications = 0
 
         config = job.pipeline.get_config(project_id=job.project.pk)
-        chunk_size = config.get("request_source_image_batch_size", 1)
+        chunk_size = config.request_source_image_batch_size
         chunks = [images[i : i + chunk_size] for i in range(0, image_count, chunk_size)]  # noqa
         request_failed_images = []
         job.logger.info(f"Processing {image_count} images in {len(chunks)} batches of up to {chunk_size}")
@@ -691,6 +696,7 @@ def process_images(cls, job, images):
     "Events created",
     "Events touched",
     "Empty events deleted",
+    "Occurrences split at a session boundary",
     "Duplicate timestamps",
     "Ungrouped captures",
     "Captures missing timestamp",
@@ -1395,8 +1401,28 @@ def check_custom_permission(self, user, action: str) -> bool:
             permission_codename = f"{action}_{job_type}_job"
 
         project = self.get_project() if hasattr(self, "get_project") else None
+        if job_type == PostProcessingJob.key and action in ("run", "retry") and not user.is_superuser:
+            if not self._members_may_run_post_processing(project):
+                return False
         return user.has_perm(permission_codename, project)
 
+    def _members_may_run_post_processing(self, project: Project | None) -> bool:
+        """Whether a project role may run this post-processing job, as opposed to staff only.
+
+        Holds for the tasks and config a member could have created through the API, so a
+        staff task or a staff-only guard setting cannot be re-run by a project role.
+        """
+        params = self.params or {}
+        task_key = params.get("task")
+        if task_key not in MEMBER_POST_PROCESSING_TASKS:
+            return False
+        config = params.get("config") or {}
+        if not isinstance(config, dict) or staff_only_config_fields(task_key, config):
+            return False
+        if task_key == TrackingTask.key and not (project and project.feature_flags.tracking):
+            return False
+        return True
+
     def get_custom_user_permissions(self, user) -> list[str]:
         project = self.get_project()
         if not project:
diff --git a/ami/jobs/serializers.py b/ami/jobs/serializers.py
index f53199e73..16025fafa 100644
--- a/ami/jobs/serializers.py
+++ b/ami/jobs/serializers.py
@@ -1,7 +1,9 @@
+import pydantic
 from django_pydantic_field.rest_framework import SchemaField
 from drf_spectacular.utils import extend_schema_field
-from rest_framework import serializers
+from rest_framework import exceptions, serializers
 
+from ami.base.permissions import TRACKING_NOT_ENABLED_MESSAGE
 from ami.exports.models import DataExport
 from ami.main.api.serializers import (
     DefaultSerializer,
@@ -9,12 +11,26 @@
     SourceImageCollectionNestedSerializer,
     SourceImageNestedSerializer,
 )
-from ami.main.models import Deployment, Project, SourceImage, SourceImageCollection
+from ami.main.models import Deployment, Event, Project, SourceImage, SourceImageCollection
 from ami.ml.models import Pipeline
+from ami.ml.post_processing.registry import (
+    MEMBER_POST_PROCESSING_TASKS,
+    get_postprocessing_task,
+    staff_only_config_fields,
+)
+from ami.ml.post_processing.tracking_task import TrackingConfig, TrackingTask
 from ami.ml.schemas import PipelineProcessingTask, PipelineTaskResult, ProcessingServiceClientInfo
 from ami.ml.serializers import PipelineNestedSerializer
 
-from .models import JOB_LOGS_DEFAULT_LIMIT, Job, JobProgress, MLJob, _legacy_logs_shape, serialize_job_logs
+from .models import (
+    JOB_LOGS_DEFAULT_LIMIT,
+    Job,
+    JobProgress,
+    MLJob,
+    PostProcessingJob,
+    _legacy_logs_shape,
+    serialize_job_logs,
+)
 from .schemas import QueuedTaskAcknowledgment
 
 
@@ -41,6 +57,73 @@ class JobTypeSerializer(serializers.Serializer):
     key = serializers.SlugField(read_only=True)
 
 
+def _pydantic_messages(exc: pydantic.ValidationError) -> list[str]:
+    messages = []
+    for err in exc.errors():
+        field = ".".join(str(part) for part in err.get("loc", ()) if part != "__root__")
+        messages.append(f"{field}: {err['msg']}" if field else err["msg"])
+    return messages
+
+
+def validate_post_processing_params(project: Project | None, params, user=None) -> dict:
+    """Check a post-processing job's ``{"task": ..., "config": {...}}`` before it is saved.
+
+    Returns the params with the config normalized by the task's schema, so the stored
+    job carries every default the worker will run with. Raises a 400 otherwise. Only a
+    superuser may set the staff-only config fields, matching who may run such a job.
+    """
+    if not isinstance(params, dict) or set(params) - {"task", "config"}:
+        raise serializers.ValidationError(
+            {"params": 'Post-processing jobs take params of the form {"task": <key>, "config": {...}}.'}
+        )
+    task_key = params.get("task")
+    task_cls = get_postprocessing_task(task_key) if isinstance(task_key, str) else None
+    if task_cls is None:
+        raise serializers.ValidationError({"params": {"task": f"Unknown post-processing task {task_key!r}."}})
+    if task_key not in MEMBER_POST_PROCESSING_TASKS:
+        raise serializers.ValidationError(
+            {"params": {"task": f"The {task_cls.name} task cannot be started through the API."}}
+        )
+    if task_cls is TrackingTask and not (project and project.feature_flags.tracking):
+        raise serializers.ValidationError({"project_id": TRACKING_NOT_ENABLED_MESSAGE})
+
+    config = params.get("config") or {}
+    if not isinstance(config, dict):
+        raise serializers.ValidationError({"params": {"config": "Must be an object."}})
+    staff_only = staff_only_config_fields(task_key, config)
+    if staff_only and not (user is not None and user.is_superuser):
+        raise serializers.ValidationError(
+            {"params": {"config": [f"{name}: Only a superuser can change this setting." for name in staff_only]}}
+        )
+    try:
+        model = task_cls.config_schema(**config)
+    except pydantic.ValidationError as exc:
+        raise serializers.ValidationError({"params": {"config": _pydantic_messages(exc)}})
+
+    if isinstance(model, TrackingConfig):
+        if model.event_ids:
+            found = set(Event.objects.filter(pk__in=model.event_ids, project=project).values_list("pk", flat=True))
+            missing = sorted(set(model.event_ids) - found)
+            if missing:
+                raise serializers.ValidationError(
+                    {"params": {"config": [f"event_ids: Session(s) {missing} were not found in this project."]}}
+                )
+        if model.source_image_collection_id is not None and not (
+            SourceImageCollection.objects.filter(pk=model.source_image_collection_id, project=project).exists()
+        ):
+            raise serializers.ValidationError(
+                {
+                    "params": {
+                        "config": [
+                            f"source_image_collection_id: Capture set {model.source_image_collection_id} "
+                            "was not found in this project."
+                        ]
+                    }
+                }
+            )
+    return {"task": task_key, "config": model.dict()}
+
+
 class JobListSerializer(DefaultSerializer):
     delay = serializers.IntegerField()
     project = JobProjectNestedSerializer(read_only=True)
@@ -55,6 +138,8 @@ class JobListSerializer(DefaultSerializer):
     # All jobs created from the Jobs UI are ML jobs (datasync, etc. are created for the user)
     # @TODO Remove this when the UI is updated pass a job type. This should be a required field.
     job_type_key = serializers.SlugField(write_only=True, default=MLJob.key)
+    # Read by post-processing jobs only: {"task": <registered task key>, "config": {...}}.
+    params = serializers.JSONField(required=False, allow_null=True)
 
     project_id = serializers.PrimaryKeyRelatedField(
         label="Project",
@@ -129,6 +214,7 @@ class Meta:
             "logs",
             "job_type",
             "job_type_key",
+            "params",
             "data_export",
             "dispatch_mode",
             # "duration",
@@ -148,6 +234,31 @@ class Meta:
             "dispatch_mode",
         ]
 
+    def validate(self, attrs: dict) -> dict:
+        attrs = super().validate(attrs)
+        if attrs.get("job_type_key") == PostProcessingJob.key:
+            project = attrs.get("project") or getattr(self.instance, "project", None)
+            request = self.context.get("request")
+            user = getattr(request, "user", None)
+            attrs["params"] = validate_post_processing_params(project, attrs.get("params"), user)
+            self._check_may_run_post_processing(project, attrs["params"])
+        else:
+            # Other job types do not read params, so none are stored for them.
+            attrs.pop("params", None)
+        return attrs
+
+    def _check_may_run_post_processing(self, project: Project | None, params: dict) -> None:
+        # Creating a post-processing job takes the permission to run it, so a role that
+        # cannot start one is refused before a job it could never run is stored.
+        request = self.context.get("request")
+        if request is None:
+            return
+        job = Job(job_type_key=PostProcessingJob.key, project=project, params=params)
+        if not job.check_custom_permission(request.user, "run"):
+            raise exceptions.PermissionDenied(
+                "You do not have permission to run post-processing jobs in this project."
+            )
+
     @extend_schema_field(
         {
             "type": "object",
diff --git a/ami/jobs/tests/test_jobs.py b/ami/jobs/tests/test_jobs.py
index 00b7934a7..9efff9b1b 100644
--- a/ami/jobs/tests/test_jobs.py
+++ b/ami/jobs/tests/test_jobs.py
@@ -1,6 +1,7 @@
 # from rich import print
 import logging
 from typing import Any
+from unittest.mock import patch
 
 from django.test import TestCase
 from guardian.shortcuts import assign_perm
@@ -23,8 +24,9 @@
 from ami.ml.models import Pipeline
 from ami.ml.models.processing_service import ProcessingService
 from ami.ml.orchestration.jobs import queue_images_to_nats
-from ami.tests.fixtures.main import create_captures
+from ami.tests.fixtures.main import create_captures, setup_test_project
 from ami.users.models import User
+from ami.users.roles import BasicMember, MLDataManager, ProjectManager
 
 logger = logging.getLogger(__name__)
 
@@ -274,6 +276,23 @@ def test_create_job_unauthenticated(self):
         # Accept either 401 (TokenAuthentication) or 403 (SessionAuthentication with AnonymousUser)
         self.assertIn(resp.status_code, [status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN])
 
+    def test_anonymous_writes_are_refused_before_the_body_is_validated(self):
+        """An unauthenticated caller learns nothing from validation errors, while reads stay public."""
+        self.client.force_authenticate(user=None)
+        jobs_create_url = reverse_with_params("api:job-list", params={"project_id": self.project.pk})
+        bodies = {
+            "empty": {},
+            "unknown job type": {"project_id": self.project.pk, "name": "x", "job_type_key": "no-such-type"},
+            "post-processing": {"project_id": self.project.pk, "job_type_key": "post_processing", "params": {}},
+        }
+        for label, body in bodies.items():
+            with self.subTest(label):
+                resp = self.client.post(jobs_create_url, body, format="json")
+                self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED, resp.data)
+        self.assertEqual(self.client.get(jobs_create_url).status_code, status.HTTP_200_OK)
+        detail_url = reverse_with_params("api:job-detail", args=[self.job.pk], params={"project_id": self.project.pk})
+        self.assertEqual(self.client.get(detail_url).status_code, status.HTTP_200_OK)
+
     def _create_job(self, name: str, start_now: bool = True):
         jobs_create_url = reverse_with_params("api:job-list", params={"project_id": self.project.pk})
 
@@ -1744,3 +1763,239 @@ def test_browsable_page_renders_number_input(self):
         html = response.content.decode()
         self.assertNotIn('<select name="source_image_single"', html)
         self.assertIn('<input type="number" name="source_image_single"', html)
+
+
+class TestTrackingJobCreation(APITestCase):
+    """Starting an occurrence tracking run through the jobs API.
+
+    Pins that a member who may create jobs can queue tracking on their own project's
+    sessions or capture set once the project has opted in, and that the request is
+    refused before a job exists when the project has not opted in, the config does not
+    fit the tracking schema, or it names sessions from another project.
+    """
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_captures(deployment=self.deployment, num_nights=2, images_per_night=2, interval_minutes=1)
+        self.project.feature_flags.tracking = True
+        self.project.save(update_fields=["feature_flags"])
+        self.events = list(Event.objects.filter(project=self.project).order_by("pk"))
+        self.collection = SourceImageCollection.objects.create(name="Tracking scope", project=self.project)
+
+        self.manager = User.objects.create_user(email="tracking-manager@insectai.org")  # type: ignore
+        self.member = User.objects.create_user(email="tracking-member@insectai.org")  # type: ignore
+        self.outsider = User.objects.create_user(email="tracking-outsider@insectai.org")  # type: ignore
+        self.superuser = User.objects.create_superuser(email="tracking-super@insectai.org")  # type: ignore
+        self.project_manager = User.objects.create_user(email="tracking-owner@insectai.org")  # type: ignore
+        MLDataManager.assign_user(self.manager, self.project)
+        ProjectManager.assign_user(self.project_manager, self.project)
+        BasicMember.assign_user(self.member, self.project)
+
+    def _body(self, **config) -> dict:
+        return {
+            "name": "Track sessions",
+            "delay": 0,
+            "project_id": self.project.pk,
+            "job_type_key": "post_processing",
+            "params": {"task": "tracking", "config": config or {"event_ids": [self.events[0].pk]}},
+        }
+
+    def _post(self, body: dict, user: User | None):
+        self.client.force_authenticate(user=user)
+        url = reverse_with_params("api:job-list", params={"project_id": self.project.pk})
+        return self.client.post(url, body, format="json")
+
+    def test_member_who_can_create_jobs_queues_tracking_on_sessions(self):
+        event_ids = [e.pk for e in self.events]
+        response = self._post(self._body(event_ids=event_ids, cost_threshold=0.5), self.manager)
+
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
+        job = Job.objects.get(pk=response.data["id"])
+        self.assertEqual(job.job_type_key, "post_processing")
+        self.assertEqual(job.project_id, self.project.pk)
+        self.assertEqual(job.params["task"], "tracking")
+        # The stored config carries the schema's defaults, so the worker runs what was validated.
+        self.assertEqual(job.params["config"]["event_ids"], event_ids)
+        self.assertEqual(job.params["config"]["cost_threshold"], 0.5)
+        self.assertTrue(job.params["config"]["require_features"])
+        self.assertEqual(response.data["params"], job.params)
+
+    def test_capture_set_scope_is_accepted(self):
+        response = self._post(self._body(source_image_collection_id=self.collection.pk), self.manager)
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
+        self.assertEqual(Job.objects.get(pk=response.data["id"]).params["config"]["event_ids"], [])
+
+    def test_refused_when_the_project_has_not_enabled_tracking(self):
+        self.project.feature_flags.tracking = False
+        self.project.save(update_fields=["feature_flags"])
+
+        response = self._post(self._body(), self.manager)
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(response.data["project_id"], ["Tracking is not enabled for this project."])
+        self.assertFalse(Job.objects.filter(job_type_key="post_processing").exists())
+
+    def test_config_that_does_not_fit_the_tracking_schema_is_refused(self):
+        cases = {
+            "no scope": {"cost_threshold": 0.3},
+            "two scopes": {"event_ids": [self.events[0].pk], "source_image_collection_id": self.collection.pk},
+            "unknown knob": {"event_ids": [self.events[0].pk], "min_speed": 3},
+            "wrong type": {"event_ids": [self.events[0].pk], "cost_threshold": "high"},
+        }
+        for label, config in cases.items():
+            with self.subTest(label):
+                response = self._post(self._body(**config), self.manager)
+                self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, response.data)
+                self.assertIn("config", response.data["params"])
+        self.assertFalse(Job.objects.filter(job_type_key="post_processing").exists())
+
+    def test_unknown_or_admin_only_tasks_are_refused(self):
+        for task in ("no-such-task", "small_size_filter"):
+            with self.subTest(task):
+                body = self._body()
+                body["params"]["task"] = task
+                response = self._post(body, self.manager)
+                self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, response.data)
+                self.assertIn("task", response.data["params"])
+
+    def test_scope_from_another_project_is_refused(self):
+        other_project, other_deployment = setup_test_project(reuse=False)
+        create_captures(deployment=other_deployment, num_nights=1, images_per_night=2, interval_minutes=1)
+        foreign_event = Event.objects.filter(project=other_project).first()
+        assert foreign_event is not None
+        foreign_collection = SourceImageCollection.objects.create(name="Elsewhere", project=other_project)
+
+        for config in (
+            {"event_ids": [self.events[0].pk, foreign_event.pk]},
+            {"source_image_collection_id": foreign_collection.pk},
+        ):
+            with self.subTest(config=config):
+                response = self._post(self._body(**config), self.manager)
+                self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, response.data)
+                self.assertIn("config", response.data["params"])
+        self.assertFalse(Job.objects.filter(job_type_key="post_processing").exists())
+
+    def test_permission_matrix(self):
+        cases = [
+            ("superuser", self.superuser, status.HTTP_201_CREATED),
+            ("ML data manager", self.manager, status.HTTP_201_CREATED),
+            ("project manager", self.project_manager, status.HTTP_201_CREATED),
+            # Creating a post-processing job takes the permission to run it, so no job is left behind.
+            ("basic member", self.member, status.HTTP_403_FORBIDDEN),
+            ("non-member", self.outsider, status.HTTP_403_FORBIDDEN),
+        ]
+        for label, user, expected in cases:
+            with self.subTest(label):
+                response = self._post(self._body(), user)
+                self.assertEqual(response.status_code, expected, response.data)
+        anonymous = self._post(self._body(), None)
+        self.assertIn(anonymous.status_code, [status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN])
+        self.assertEqual(Job.objects.filter(job_type_key="post_processing").count(), 3)
+
+    def test_a_basic_member_cannot_create_one_to_start_later(self):
+        response = self._post(self._body(), self.member)
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
+        self.assertFalse(Job.objects.filter(job_type_key="post_processing").exists())
+
+    def test_start_now_enqueues_for_a_user_who_may_run_it(self):
+        self.client.force_authenticate(user=self.superuser)
+        url = reverse_with_params("api:job-list", params={"project_id": self.project.pk, "start_now": "true"})
+        with patch.object(Job, "enqueue") as enqueue:
+            response = self.client.post(url, self._body(), format="json")
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
+        enqueue.assert_called_once()
+
+    def test_safety_guards_can_only_be_changed_by_staff(self):
+        for field in ("require_fresh_event", "skip_if_human_identifications"):
+            with self.subTest(field):
+                response = self._post(self._body(event_ids=[self.events[0].pk], **{field: False}), self.manager)
+                self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, response.data)
+                self.assertEqual(
+                    response.data["params"]["config"], [f"{field}: Only a superuser can change this setting."]
+                )
+        self.assertFalse(Job.objects.filter(job_type_key="post_processing").exists())
+
+        # Restating a guard at its default is accepted.
+        response = self._post(self._body(event_ids=[self.events[0].pk], require_fresh_event=True), self.manager)
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
+
+    def test_a_superuser_can_create_a_run_with_staff_only_settings(self):
+        """The fields a member may not set are refused to members and accepted from a superuser."""
+        body = self._body(
+            event_ids=[self.events[0].pk], require_fresh_event=False, skip_if_human_identifications=False
+        )
+        refused = self._post(body, self.manager)
+        self.assertEqual(refused.status_code, status.HTTP_400_BAD_REQUEST, refused.data)
+
+        created = self._post(body, self.superuser)
+        self.assertEqual(created.status_code, status.HTTP_201_CREATED, created.data)
+        config = Job.objects.get(pk=created.data["id"]).params["config"]
+        self.assertEqual((config["require_fresh_event"], config["skip_if_human_identifications"]), (False, False))
+
+    def _run(self, job: Job, user: User):
+        self.client.force_authenticate(user=user)
+        url = reverse_with_params("api:job-run", args=[job.pk], params={"project_id": self.project.pk})
+        with patch.object(Job, "enqueue") as enqueue:
+            response = self.client.post(url, format="json")
+        return response, enqueue
+
+    def _staff_job(self, task: str, config: dict) -> Job:
+        return Job.objects.create(
+            name="Staff run",
+            project=self.project,
+            job_type_key="post_processing",
+            params={"task": task, "config": config},
+        )
+
+    def test_ml_data_manager_can_start_a_tracking_run_a_member_created(self):
+        created = self._post(self._body(), self.manager)
+        self.assertEqual(created.status_code, status.HTTP_201_CREATED, created.data)
+        job = Job.objects.get(pk=created.data["id"])
+
+        cases = [
+            ("ML data manager", self.manager, status.HTTP_200_OK),
+            ("project manager", self.project_manager, status.HTTP_200_OK),
+            ("basic member", self.member, status.HTTP_403_FORBIDDEN),
+            ("non-member", self.outsider, status.HTTP_403_FORBIDDEN),
+            ("superuser", self.superuser, status.HTTP_200_OK),
+        ]
+        for label, user, expected in cases:
+            with self.subTest(label):
+                response, enqueue = self._run(job, user)
+                self.assertEqual(response.status_code, expected, response.data)
+                self.assertEqual(enqueue.called, expected == status.HTTP_200_OK)
+
+    def test_ml_data_manager_cannot_run_staff_post_processing(self):
+        """Staff tasks, staff-only guard settings and tracking without the flag stay superuser-only."""
+        tracking_config = {"event_ids": [self.events[0].pk]}
+        staff_jobs = {
+            "staff task": self._staff_job("small_size_filter", {"source_image_collection_id": self.collection.pk}),
+            "guard turned off": self._staff_job("tracking", {**tracking_config, "require_fresh_event": False}),
+        }
+        for label, job in staff_jobs.items():
+            with self.subTest(label):
+                response, enqueue = self._run(job, self.manager)
+                self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
+                enqueue.assert_not_called()
+                response, enqueue = self._run(job, self.superuser)
+                self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
+
+        job = self._staff_job("tracking", tracking_config)
+        self.project.feature_flags.tracking = False
+        self.project.save(update_fields=["feature_flags"])
+        response, enqueue = self._run(job, self.manager)
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
+        enqueue.assert_not_called()
+
+    def test_params_are_not_stored_for_other_job_types(self):
+        body = {
+            "name": "Populate",
+            "delay": 0,
+            "project_id": self.project.pk,
+            "job_type_key": SourceImageCollectionPopulateJob.key,
+            "source_image_collection_id": self.collection.pk,
+            "params": {"task": "tracking"},
+        }
+        response = self._post(body, self.superuser)
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
+        self.assertIsNone(Job.objects.get(pk=response.data["id"]).params)
diff --git a/ami/jobs/views.py b/ami/jobs/views.py
index 380d9f959..53712eaed 100644
--- a/ami/jobs/views.py
+++ b/ami/jobs/views.py
@@ -14,6 +14,7 @@
 from rest_framework.decorators import action
 from rest_framework.exceptions import PermissionDenied, ValidationError
 from rest_framework.filters import BaseFilterBackend
+from rest_framework.permissions import IsAuthenticatedOrReadOnly
 from rest_framework.response import Response
 
 from ami.base.filters import RelatedIdFilter
@@ -40,7 +41,7 @@
 from ami.main.api.views import DefaultViewSet
 from ami.utils.fields import url_boolean_param
 
-from .models import Job, JobDispatchMode, JobState
+from .models import Job, JobDispatchMode, JobState, PostProcessingJob
 from .serializers import JobListSerializer, JobSerializer, MinimalJobSerializer
 
 logger = logging.getLogger(__name__)
@@ -228,7 +229,8 @@ class JobViewSet(DefaultViewSet, ProjectMixin):
         "pipeline",
     ]
 
-    permission_classes = [ObjectPermission]
+    # Anonymous writes are refused before the body is validated; reads stay public.
+    permission_classes = [IsAuthenticatedOrReadOnly, ObjectPermission]
 
     def get_serializer_class(self):
         """
@@ -306,15 +308,16 @@ def perform_create(self, serializer):
         obj = serializer.Meta.model(**serializer.validated_data)
         # Check permissions before saving
         self.check_object_permissions(self.request, obj)
+        start_now = url_boolean_param(self.request, "start_now", default=False)
+        # Check the run permission before saving, so a refusal leaves no job behind. A
+        # post-processing job needs it even unstarted: its creator could neither run nor delete it.
+        if start_now or obj.job_type_key == PostProcessingJob.key:
+            if not obj.check_custom_permission(self.request.user, "run"):
+                raise PermissionDenied("You do not have permission to run this job.")
 
         job: Job = serializer.save()  # type: ignore
-        if url_boolean_param(self.request, "start_now", default=False):
-            if job.check_custom_permission(self.request.user, "run"):
-                # If the user has permission, enqueue the job
-                job.enqueue()
-            else:
-                # If the user does not have permission, raise an error
-                raise PermissionDenied("You do not have permission to run this job.")
+        if start_now:
+            job.enqueue()
 
     def get_queryset(self) -> QuerySet:
         jobs = super().get_queryset()
diff --git a/ami/main/admin.py b/ami/main/admin.py
index 55c84701f..a7c158e07 100644
--- a/ami/main/admin.py
+++ b/ami/main/admin.py
@@ -16,8 +16,11 @@
 from ami.ml.post_processing.admin.actions import make_post_processing_action
 from ami.ml.post_processing.admin.class_masking_form import ClassMaskingActionForm
 from ami.ml.post_processing.admin.small_size_filter_form import SmallSizeFilterActionForm
+from ami.ml.post_processing.admin.tracking_actions import build_tracking_jobs_for_events
+from ami.ml.post_processing.admin.tracking_form import TrackingActionForm
 from ami.ml.post_processing.class_masking import ClassMaskingTask
 from ami.ml.post_processing.small_size_filter import SmallSizeFilterTask
+from ami.ml.post_processing.tracking_task import TrackingTask
 from ami.ml.tasks import remove_duplicate_classifications
 
 from .models import (
@@ -314,8 +317,17 @@ def update_calculated_fields(self, request: HttpRequest, queryset: QuerySet[Even
         update_calculated_fields_for_events(qs=queryset)
         self.message_user(request, f"Updated {queryset.count()} events.")
 
+    # Built from the shared post-processing action factory. Sessions can be selected
+    # across projects here, so a custom builder partitions the selection: one Job per
+    # project, carrying that project's event ids.
+    run_tracking = make_post_processing_action(
+        TrackingTask,
+        TrackingActionForm,
+        build_jobs=build_tracking_jobs_for_events,
+    )
+
     list_filter = ("deployment", "project", "start")
-    actions = [update_calculated_fields]
+    actions = [update_calculated_fields, run_tracking]
 
 
 @admin.register(SourceImage)
@@ -859,11 +871,20 @@ def populate_collection_async(self, request: HttpRequest, queryset: QuerySet[Sou
             f"Post-processing: {task_cls.name} on Capture Set {collection.pk}"
         ),
     )
+    run_tracking = make_post_processing_action(
+        TrackingTask,
+        TrackingActionForm,
+        scope_resolver=lambda collection: {"source_image_collection_id": collection.pk},
+        name_resolver=lambda task_cls, collection: (
+            f"Post-processing: {task_cls.name} on Capture Set {collection.pk}"
+        ),
+    )
     actions = [
         populate_collection,
         populate_collection_async,
         run_small_size_filter,
         run_class_masking,
+        run_tracking,
     ]
 
     # Hide images many-to-many field from form. This would list all source images in the database.
diff --git a/ami/main/api/serializers.py b/ami/main/api/serializers.py
index 962c802af..946e1548c 100644
--- a/ami/main/api/serializers.py
+++ b/ami/main/api/serializers.py
@@ -13,6 +13,11 @@
 from ami.base.views import get_active_project
 from ami.jobs.models import Job
 from ami.main.models import Tag
+from ami.main.models_future.merge_candidates import CAPTURE_MATCH_RELATIONS
+from ami.main.models_future.merge_candidates import MAX_CANDIDATES as MAX_MERGE_CANDIDATES
+from ami.main.models_future.merge_candidates import RELATIONS as MERGE_CANDIDATE_RELATIONS
+from ami.main.models_future.merge_candidates import SKIPPED_REASONS as CAPTURE_MATCH_SKIPPED_REASONS
+from ami.main.models_future.occurrence import OCCURRENCE_FRAMES_PAGE_SIZE, frames_from_prefetch
 from ami.ml.models import Algorithm, Pipeline
 from ami.ml.serializers import AlgorithmSerializer, PipelineNestedSerializer
 from ami.users.models import User
@@ -1067,6 +1072,11 @@ class Meta:
 class CaptureOccurrenceSerializer(DefaultSerializer):
     determination = TaxonNoParentNestedSerializer(read_only=True)
     determination_algorithm = AlgorithmSerializer(read_only=True)
+    # Annotated by the capture viewset's detections prefetch. The session toolbar reads
+    # it to say how many frames an occurrence spans before deciding whether to ask for
+    # its path, so a one-frame occurrence is never offered a fetch that returns nothing.
+    detections_count = serializers.IntegerField(read_only=True)
+    grouping_verified_by = serializers.SerializerMethodField()
 
     class Meta:
         model = Occurrence
@@ -1076,8 +1086,18 @@ class Meta:
             "determination",
             "determination_score",
             "determination_algorithm",
+            "detections_count",
+            # Whether a person confirmed this occurrence holds the right detections.
+            # The session view offers to undo a confirmation rather than repeat it, and
+            # can show which occurrences have been checked without a further request.
+            "grouping_verified",
+            "grouping_verified_at",
+            "grouping_verified_by",
         ]
 
+    def get_grouping_verified_by(self, obj: Occurrence) -> str | None:
+        return obj.grouping_verified_by.name if obj.grouping_verified_by else None
+
 
 class ClassificationPredictionItemSerializer(serializers.Serializer):
     taxon = TaxonNestedSerializer(read_only=True)
@@ -1157,6 +1177,14 @@ class Meta:
 
 
 class ClassificationNestedSerializer(ClassificationSerializer):
+    # Annotated by ClassificationQuerySet.with_has_features(); null when the queryset
+    # did not annotate it. The embedding itself is never serialized.
+    has_features = serializers.BooleanField(
+        read_only=True,
+        allow_null=True,
+        help_text="Whether a feature embedding was stored for this classification.",
+    )
+
     def get_permissions(self, instance, instance_data):
         instance_data["user_permissions"] = []
         return instance_data
@@ -1169,6 +1197,7 @@ class Meta:
             "taxon",
             "score",
             "terminal",
+            "has_features",
             "algorithm",
             "applied_to",
             "created_at",
@@ -1239,6 +1268,39 @@ class Meta:
         ]
 
 
+class OccurrenceFrameCaptureSerializer(DetectionCaptureNestedSerializer):
+    def get_permissions(self, instance, instance_data):
+        instance_data["user_permissions"] = []
+        return instance_data
+
+
+class OccurrenceFrameSerializer(DetectionNestedSerializer):
+    """One detection of an occurrence, with its position in the occurrence's frames.
+
+    Frame edits are gated on the occurrence's permissions, so no per-frame permissions
+    are looked up: that would cost queries for every frame.
+    """
+
+    capture = OccurrenceFrameCaptureSerializer(read_only=True, source="source_image")
+    frame_index = serializers.IntegerField(
+        read_only=True, help_text="Zero-based position among the occurrence's detections in capture order."
+    )
+
+    class Meta(DetectionNestedSerializer.Meta):
+        fields = DetectionNestedSerializer.Meta.fields + ["frame_index"]
+
+    def get_permissions(self, instance, instance_data):
+        instance_data["user_permissions"] = []
+        return instance_data
+
+
+class OccurrenceFrameSummarySerializer(serializers.Serializer):
+    id = serializers.IntegerField()
+    timestamp = serializers.DateTimeField(allow_null=True)
+    capture_id = serializers.IntegerField()
+    frame_index = serializers.IntegerField()
+
+
 class DetectionListSerializer(DefaultSerializer):
     class Meta:
         model = Detection
@@ -1322,6 +1384,16 @@ class SourceImageSerializer(SourceImageListSerializer):
     uploaded_by = serializers.PrimaryKeyRelatedField(read_only=True)
     jobs = JobStatusSerializer(many=True, read_only=True)
     collections = SourceImageCollectionNestedSerializer(many=True, read_only=True)
+    # Annotated by SourceImageQuerySet.with_detections_with_features() on the detail
+    # queryset only; the keys are omitted wherever they are not annotated.
+    detections_valid = serializers.IntegerField(
+        read_only=True,
+        help_text="Valid detections on this capture, the total detections_with_features is out of.",
+    )
+    detections_with_features = serializers.IntegerField(
+        read_only=True,
+        help_text="Valid detections with at least one classification that stored a feature embedding.",
+    )
     # file = serializers.ImageField(allow_empty_file=False, use_url=True)
 
     class Meta:
@@ -1331,8 +1403,12 @@ class Meta:
             "test_image",
             "jobs",
             "collections",
+            "detections_valid",
+            "detections_with_features",
             "event_next_capture_id",
             "event_prev_capture_id",
+            "event_next_capture_with_detections_id",
+            "event_prev_capture_with_detections_id",
             "event_current_capture_index",
             "event_total_captures",
         ]
@@ -1499,6 +1575,50 @@ class Meta:
         ]
 
 
+class TrackStatsSerializer(serializers.Serializer):
+    """Per-occurrence track statistics; the definitions live in ``models_future/track_stats.py``."""
+
+    frames = serializers.IntegerField()
+    motion = serializers.FloatField()
+    size_ratio = serializers.FloatField()
+    distinct_taxa = serializers.IntegerField()
+    id_agreement = serializers.FloatField(allow_null=True)
+
+
+class TrackingAlgorithmSerializer(serializers.Serializer):
+    id = serializers.IntegerField()
+    name = serializers.CharField()
+    key = serializers.CharField()
+
+
+class FrameNameTaxonSerializer(serializers.Serializer):
+    id = serializers.IntegerField()
+    name = serializers.CharField()
+    rank = serializers.CharField()
+
+
+class FrameNameSerializer(serializers.Serializer):
+    """One distinct label across a track's frames. A null taxon counts unlabelled frames."""
+
+    taxon = FrameNameTaxonSerializer(allow_null=True)
+    frames = serializers.IntegerField()
+    score_max = serializers.FloatField(allow_null=True)
+
+
+class GroupingSummarySerializer(TrackStatsSerializer):
+    """How an occurrence's detections hang together, computed on read from the current detections."""
+
+    derived = serializers.BooleanField()
+    algorithm = TrackingAlgorithmSerializer(allow_null=True)
+    frames_with_vectors = serializers.IntegerField()
+    linked_detections = serializers.IntegerField()
+    duration_seconds = serializers.FloatField(allow_null=True)
+    score_min = serializers.FloatField(allow_null=True)
+    score_mean = serializers.FloatField(allow_null=True)
+    score_max = serializers.FloatField(allow_null=True)
+    frame_names = FrameNameSerializer(many=True)
+
+
 class OccurrenceListSerializer(DefaultSerializer):
     # List cards render one cover image; detail subclass raises this to 100.
     detection_images_limit: int | None = 1
@@ -1511,16 +1631,23 @@ class OccurrenceListSerializer(DefaultSerializer):
     determination_details = serializers.SerializerMethodField()
     best_machine_prediction = serializers.SerializerMethodField()
     identifications = OccurrenceIdentificationSerializer(many=True, read_only=True)
+    track_stats = serializers.SerializerMethodField()
 
     def get_permissions(self, instance, instance_data):
         request: Request = self.context["request"]
         user = request.user
         project = instance.get_project()
+        project_perms = get_perms(user, project)
         permissions = set()
-        if Project.Permissions.CREATE_IDENTIFICATION in get_perms(user, project):
+        if Project.Permissions.CREATE_IDENTIFICATION in project_perms:
             # check if the user has identification permissions on this project,
             # then add  update permission to response
             permissions.add("update")
+        if Project.Permissions.DELETE_OCCURRENCES in project_perms:
+            # Mirrors Occurrence.check_custom_permission: this is the right the track
+            # editing actions are gated on, so the interface can only offer them when
+            # the API would accept them.
+            permissions.add("delete")
 
         instance_data["user_permissions"] = list(permissions)
         return instance_data
@@ -1550,6 +1677,7 @@ class Meta:
             "determination_details",
             "best_machine_prediction",
             "identifications",
+            "track_stats",
             "created_at",
             "updated_at",
         ]
@@ -1559,6 +1687,13 @@ def get_detection_images(self, obj: Occurrence) -> list[str]:
 
         return detection_image_urls_from_prefetch(obj, limit=self.detection_images_limit)
 
+    @extend_schema_field(TrackStatsSerializer(allow_null=True))
+    def get_track_stats(self, obj: Occurrence) -> dict | None:
+        from ami.main.models_future.track_stats import stored_track_stats
+
+        # Null until tracking, a track edit or the backfill has stored the numbers.
+        return stored_track_stats(obj, frames=obj.detections_count)  # type: ignore[attr-defined]
+
     def get_determination_details(self, obj: Occurrence):
         from ami.main.models_future.occurrence import best_identification_from_prefetch, best_prediction_from_prefetch
 
@@ -1619,26 +1754,81 @@ def get_best_machine_prediction(self, obj: Occurrence) -> dict | None:
 
 class OccurrenceSerializer(OccurrenceListSerializer):
     detection_images_limit: int | None = 100
+    # The detail carries the first page of frames so it renders without a second
+    # request; the rest come from the detections action, which pages the same way.
+    detections_page_size = OCCURRENCE_FRAMES_PAGE_SIZE
 
     determination = CaptureTaxonSerializer(read_only=True)
-    detections = DetectionNestedSerializer(many=True, read_only=True)
+    detections = serializers.SerializerMethodField(
+        help_text="The first page of the occurrence's detections in capture order. "
+        "Page through the rest with the occurrence's detections endpoint."
+    )
+    first_detection = serializers.SerializerMethodField()
+    last_detection = serializers.SerializerMethodField()
     identifications = OccurrenceIdentificationSerializer(many=True, read_only=True)
     predictions = ClassificationNestedSerializer(many=True, read_only=True)
     deployment = DeploymentNestedSerializer(read_only=True)
     event = EventNestedSerializer(read_only=True)
+    grouping_verified_by = UserNestedSerializer(read_only=True)
+    grouping_summary = serializers.SerializerMethodField()
     # first_appearance = TaxonSourceImageNestedSerializer(read_only=True)
 
     class Meta:
         model = Occurrence
-        fields = OccurrenceListSerializer.Meta.fields + [
+        # The stored track_stats belong to the list; the detail carries grouping_summary,
+        # computed live from the current detections, instead.
+        fields = [name for name in OccurrenceListSerializer.Meta.fields if name != "track_stats"] + [
             "determination_id",
             "detections",
+            "first_detection",
+            "last_detection",
             "predictions",
+            # Whether a person confirmed this occurrence holds the right detections,
+            # which is a separate judgement from the taxon it was identified as.
+            "grouping_verified",
+            "grouping_verified_at",
+            "grouping_verified_by",
+            "grouping_summary",
         ]
         read_only_fields = [
             "determination_score",
         ]
 
+    @extend_schema_field(OccurrenceFrameSerializer(many=True))
+    def get_detections(self, obj: Occurrence) -> list[dict]:
+        frames = frames_from_prefetch(obj)[: self.detections_page_size]
+        return OccurrenceFrameSerializer(frames, many=True, context=self.context).data
+
+    def _frame_summary(self, detection: Detection | None) -> dict | None:
+        if detection is None:
+            return None
+        return {
+            "id": detection.pk,
+            "timestamp": detection.source_image.timestamp,
+            "capture_id": detection.source_image_id,
+            "frame_index": detection.frame_index,
+        }
+
+    @extend_schema_field(OccurrenceFrameSummarySerializer(allow_null=True))
+    def get_first_detection(self, obj: Occurrence) -> dict | None:
+        frames = frames_from_prefetch(obj)
+        return self._frame_summary(frames[0] if frames else None)
+
+    @extend_schema_field(OccurrenceFrameSummarySerializer(allow_null=True))
+    def get_last_detection(self, obj: Occurrence) -> dict | None:
+        frames = frames_from_prefetch(obj)
+        return self._frame_summary(frames[-1] if frames else None)
+
+    @extend_schema_field(GroupingSummarySerializer())
+    def get_grouping_summary(self, obj: Occurrence) -> dict:
+        from ami.main.models_future.track_stats import grouping_summary_from_prefetch, tracking_algorithm_summary
+
+        context = self.context
+        if "tracking_algorithm" not in context:
+            # One lookup per request; the row is absent where the tracking task never ran.
+            context["tracking_algorithm"] = tracking_algorithm_summary()
+        return grouping_summary_from_prefetch(obj, context["tracking_algorithm"])
+
 
 class EventCaptureNestedSerializer(SourceImageThumbnailSerializer):
     """
@@ -2061,3 +2251,256 @@ class ModelAgreementSerializer(serializers.Serializer):
         required=False,
         help_text="agreed_coarser_rank_count / comparable_count. Null when no threshold supplied.",
     )
+
+
+class TrackEditSerializer(serializers.Serializer):
+    """Body for the track edit actions: which detection in the track to act on."""
+
+    detection_id = serializers.IntegerField(
+        help_text="A detection belonging to this occurrence.",
+    )
+
+
+class TrackEditResultSerializer(serializers.Serializer):
+    """What a track edit produced.
+
+    Only identifiers are returned: the caller refetches both occurrences through
+    the list or detail endpoints, which is where the prefetches those serializers
+    require are wired up.
+    """
+
+    occurrence_id = serializers.IntegerField(help_text="The occurrence that was edited.")
+    occurrence_detections_count = serializers.IntegerField(help_text="Detections it has left.")
+    new_occurrence_id = serializers.IntegerField(help_text="The occurrence the detections moved into.")
+    new_occurrence_detections_count = serializers.IntegerField(help_text="Detections it received.")
+
+
+class OccurrenceMergeSerializer(serializers.Serializer):
+    """Body for merging other occurrences into this one."""
+
+    occurrence_ids = serializers.ListField(
+        child=serializers.IntegerField(),
+        min_length=1,
+        help_text="Occurrences to fold into this one. They must be in the same session.",
+    )
+
+
+class OccurrenceAddDetectionsSerializer(serializers.Serializer):
+    """Body for moving individual detections into this occurrence."""
+
+    detection_ids = serializers.ListField(
+        child=serializers.IntegerField(),
+        min_length=1,
+        help_text="Detections to move into this occurrence, from wherever they are now.",
+    )
+
+
+class OccurrenceGroupingSerializer(serializers.Serializer):
+    """The state of one occurrence after its detections or its verification changed."""
+
+    occurrence_id = serializers.IntegerField()
+    detections_count = serializers.IntegerField()
+    grouping_verified = serializers.BooleanField(
+        help_text="Whether a person has confirmed this occurrence holds the right detections."
+    )
+    grouping_verified_at = serializers.DateTimeField(allow_null=True)
+    grouping_verified_by = serializers.CharField(allow_null=True)
+
+
+class OccurrencePathCaptureSerializer(serializers.Serializer):
+    """The capture one frame of a path was measured against."""
+
+    id = serializers.IntegerField()
+    timestamp = serializers.DateTimeField(allow_null=True)
+    width = serializers.IntegerField(
+        allow_null=True,
+        help_text="Stored pixel width of the capture. A box is measured in this space, "
+        "so drawing it over a different frame requires these dimensions rather than "
+        "those of the frame being viewed.",
+    )
+    height = serializers.IntegerField(allow_null=True)
+
+
+class OccurrencePathFrameSerializer(serializers.Serializer):
+    """One frame of an occurrence's path: a box and the capture it belongs to."""
+
+    detection_id = serializers.IntegerField()
+    bbox = serializers.ListField(child=serializers.FloatField(), allow_null=True)
+    crop_url = serializers.CharField(
+        allow_null=True,
+        help_text="The detection's cropped image, drawn inside the box so a reviewer can "
+        "read the animal in a frame they are not viewing. Null until the crop is generated.",
+    )
+    capture = OccurrencePathCaptureSerializer()
+
+
+class MergeCandidateDeterminationSerializer(serializers.Serializer):
+    id = serializers.IntegerField()
+    name = serializers.CharField()
+
+
+class MergeCandidateSerializer(serializers.Serializer):
+    """One occurrence the requested occurrence could be merged with, and how well it fits.
+
+    The fit is judged from the two frames nearest in time: the requested
+    occurrence's first or last frame and the candidate's frame closest to it.
+    """
+
+    id = serializers.IntegerField()
+    determination = MergeCandidateDeterminationSerializer(allow_null=True)
+    detections_count = serializers.IntegerField()
+    first_appearance_timestamp = serializers.DateTimeField(allow_null=True)
+    last_appearance_timestamp = serializers.DateTimeField(allow_null=True)
+    relation = serializers.ChoiceField(
+        choices=MERGE_CANDIDATE_RELATIONS,
+        help_text="Where the candidate sits in time: before or after the requested occurrence, or in a gap of "
+        "it, on captures inside its span that it has no frame on.",
+    )
+    time_offset_seconds = serializers.FloatField(
+        help_text="Gap between the two spans: negative when the candidate ends first, positive when it starts "
+        "after the requested occurrence ends, zero for a candidate in a gap.",
+    )
+    distance = serializers.FloatField(
+        allow_null=True,
+        help_text="Centre-to-centre distance between the nearest pair of boxes as a fraction of the frame diagonal.",
+    )
+    similarity = serializers.FloatField(
+        allow_null=True,
+        help_text="Cosine similarity of the nearest pair's feature vectors, from the algorithm that produced the "
+        "requested occurrence's vector. Null when either frame has none.",
+    )
+    cost = serializers.FloatField(
+        allow_null=True,
+        help_text="The tracking method's matching cost for the nearest pair; lower fits better. Uses the geometry "
+        "terms only when similarity is null.",
+    )
+    iou = serializers.FloatField(
+        allow_null=True, help_text="Overlap of the nearest pair of boxes, intersection over union."
+    )
+    size_ratio = serializers.FloatField(
+        allow_null=True, help_text="Area of the smaller of the two boxes over that of the larger."
+    )
+    likelihood = serializers.FloatField(
+        allow_null=True,
+        help_text="1 minus the mean term of the tracking cost, from 0 to 1, higher fits better. The tracker's own "
+        "decision is would_link.",
+    )
+    would_link = serializers.BooleanField(
+        help_text="Whether the pair passes the tracker's pairing rule: a cost under cost_threshold, with a feature "
+        "vector on both frames when requires_features is set. The rule alone; tracking only pairs adjacent "
+        "captures and claims each box once."
+    )
+    image = serializers.CharField(allow_null=True, help_text="A crop of the candidate, nearest frame first.")
+    capture_id = serializers.IntegerField(
+        allow_null=True,
+        help_text="The capture holding the candidate's frame in the scored pair, the one `image` is cropped from.",
+    )
+    image_timestamp = serializers.DateTimeField(allow_null=True, help_text="When that frame was captured.")
+    edge_image = serializers.CharField(
+        allow_null=True,
+        help_text="A crop of the track frame in the scored pair: its first frame for a before candidate, its last "
+        "for an after one, the nearest one in time for a gap candidate.",
+    )
+    edge_timestamp = serializers.DateTimeField(allow_null=True, help_text="When that track frame was captured.")
+
+
+class MergeCandidatesResponseSerializer(serializers.Serializer):
+    """Candidates before, after or in a gap of the requested occurrence, ordered by cost, lowest first."""
+
+    candidates = MergeCandidateSerializer(
+        many=True,
+        help_text=f"At most {MAX_MERGE_CANDIDATES}. Occurrences with a frame on one of the requested occurrence's "
+        "captures are other animals and are left out.",
+    )
+    cost_threshold = serializers.FloatField(help_text="Tracking links a pair only below this cost.")
+    requires_features = serializers.BooleanField(
+        help_text="Whether tracking skips detections without an embedding rather than matching them on geometry."
+    )
+
+
+class CaptureMatchReferenceSerializer(serializers.Serializer):
+    """The track frame every box on the capture was scored against."""
+
+    detection_id = serializers.IntegerField()
+    capture_id = serializers.IntegerField()
+    timestamp = serializers.DateTimeField()
+    relation = serializers.ChoiceField(
+        choices=CAPTURE_MATCH_RELATIONS,
+        help_text="Where the capture sits against the track: before its first frame, after its last, in a gap "
+        "of it, or on a capture that already holds one of its frames (same).",
+    )
+    capture_offset = serializers.IntegerField(
+        allow_null=True,
+        help_text="Captures from the reference frame's capture to this one, signed: 1 is the adjacent capture "
+        "tracking pairs, -1 the one before.",
+    )
+    skipped_reason = serializers.ChoiceField(
+        choices=CAPTURE_MATCH_SKIPPED_REASONS,
+        allow_null=True,
+        help_text="no_vector when tracking would skip this frame for lacking an embedding while it requires them.",
+    )
+
+
+class CaptureMatchSerializer(serializers.Serializer):
+    """One box on the capture and how likely it is to be the requested occurrence's animal."""
+
+    detection_id = serializers.IntegerField()
+    occurrence_id = serializers.IntegerField(allow_null=True, help_text="Null for a box that was never grouped.")
+    in_track = serializers.BooleanField(help_text="The requested occurrence's own box on this capture; unscored.")
+    would_link = serializers.BooleanField(
+        help_text="Whether tracking's matcher, run between this capture and the reference frame's capture, links "
+        "the reference frame to this box."
+    )
+    skipped_reason = serializers.ChoiceField(
+        choices=CAPTURE_MATCH_SKIPPED_REASONS,
+        allow_null=True,
+        help_text="no_vector when tracking would skip this box for lacking an embedding while it requires them. "
+        "Its cost is then geometry alone.",
+    )
+    likelihood = serializers.FloatField(
+        allow_null=True,
+        help_text="1 minus the mean term of the tracking cost, from 0 to 1, higher fits better. Comparable across "
+        "captures; the tracker's own decision is would_link.",
+    )
+    cost = serializers.FloatField(
+        allow_null=True,
+        help_text="The tracking method's matching cost against the reference frame; lower fits better. Uses the "
+        "geometry terms only when similarity is null.",
+    )
+    distance = serializers.FloatField(
+        allow_null=True,
+        help_text="Centre-to-centre distance to the reference box as a fraction of the frame diagonal.",
+    )
+    iou = serializers.FloatField(allow_null=True, help_text="Overlap with the reference box, intersection over union.")
+    size_ratio = serializers.FloatField(
+        allow_null=True, help_text="Area of the smaller of the two boxes over that of the larger."
+    )
+    similarity = serializers.FloatField(
+        allow_null=True,
+        help_text="Cosine similarity to the reference frame's feature vector, from the same algorithm. Null when "
+        "either has none.",
+    )
+    time_offset_seconds = serializers.FloatField(
+        allow_null=True, help_text="Capture time minus reference time; negative when the capture is earlier."
+    )
+
+
+class CaptureMatchesResponseSerializer(serializers.Serializer):
+    """Every box on one capture scored against the requested occurrence's track, best match first."""
+
+    capture_id = serializers.IntegerField()
+    cost_threshold = serializers.FloatField(help_text="Tracking links a pair only below this cost.")
+    feature_algorithm_id = serializers.IntegerField(
+        allow_null=True,
+        help_text="The feature extractor tracking would compare embeddings from, read from the two captures being "
+        "paired. Null when they carry none or more than one.",
+    )
+    requires_features = serializers.BooleanField(
+        help_text="Whether tracking skips detections without an embedding rather than matching them on geometry."
+    )
+    reference = CaptureMatchReferenceSerializer(
+        allow_null=True,
+        help_text="The track frame nearest in time on another capture. Null when the track has no other frame, "
+        "and then every score is null.",
+    )
+    detections = CaptureMatchSerializer(many=True)
diff --git a/ami/main/api/views.py b/ami/main/api/views.py
index fdc72c963..4d281907a 100644
--- a/ami/main/api/views.py
+++ b/ami/main/api/views.py
@@ -7,7 +7,8 @@
 from django.core import exceptions
 from django.core.files.storage import default_storage
 from django.db import models
-from django.db.models import OuterRef, Prefetch, Q, Subquery
+from django.db.models import F, OuterRef, Prefetch, Q, Subquery, Window
+from django.db.models.functions import RowNumber
 from django.db.models.query import QuerySet
 from django.forms import BooleanField, CharField, IntegerField
 from django.shortcuts import get_object_or_404, redirect
@@ -23,19 +24,47 @@
 from rest_framework.generics import GenericAPIView
 from rest_framework.request import Request
 from rest_framework.response import Response
+from rest_framework.utils.urls import remove_query_param
 from rest_framework.views import APIView
 
 from ami.base.filters import NullsLastOrderingFilter, RelatedIdFilter, ThresholdFilter
 from ami.base.metadata import ResponseSchemaMetadata
 from ami.base.models import BaseQuerySet
 from ami.base.pagination import LimitOffsetPaginationWithPermissions
-from ami.base.permissions import IsActiveStaffOrReadOnly, IsProjectMemberOrReadOnly, ObjectPermission
+from ami.base.permissions import IsActiveStaffOrReadOnly, IsProjectMemberOrReadOnly, ObjectPermission, TrackingEnabled
 from ami.base.serializers import FilterParamsSerializer, SingleParamSerializer
 from ami.base.views import ProjectMixin
 from ami.main.api.schemas import limit_doc_param, project_id_doc_param
 from ami.main.api.serializers import TagSerializer
 from ami.main.models_future.identifications import create_identifications_batch, resolve_occurrences
-from ami.main.models_future.occurrence import model_agreement_for_project, top_identifiers_for_project
+from ami.main.models_future.merge_candidates import (
+    DEFAULT_ADJACENT_CAPTURES,
+    MAX_ADJACENT_CAPTURES,
+    MAX_WINDOW_MINUTES,
+    DetectionNotInOccurrence,
+    match_capture_detections,
+    rank_merge_candidates,
+    tracking_config_for,
+)
+from ami.main.models_future.occurrence import (
+    OCCURRENCE_FRAMES_PAGE_SIZE,
+    model_agreement_for_project,
+    occurrence_path,
+    prefetch_nested_classifications,
+    top_identifiers_for_project,
+)
+from ami.main.models_future.tracks import (
+    CAPTURE_ORDER,
+    SessionBusy,
+    TrackEditError,
+    add_detections,
+    detach_detection,
+    merge_occurrences,
+    refuse_edit_outside_session,
+    split_track,
+    unverify_grouping,
+    verify_grouping,
+)
 from ami.ml.models.algorithm import Algorithm
 from ami.ml.serializers import AlgorithmSerializer
 from ami.utils.requests import get_default_classification_threshold
@@ -68,6 +97,7 @@
 from .serializers import (
     BulkIdentificationRequestSerializer,
     BulkIdentificationResponseSerializer,
+    CaptureMatchesResponseSerializer,
     ClassificationListSerializer,
     ClassificationSerializer,
     ClassificationWithTaxaSerializer,
@@ -81,8 +111,14 @@
     EventTimelineSerializer,
     ExampleOccurrenceSerializer,
     IdentificationSerializer,
+    MergeCandidatesResponseSerializer,
     ModelAgreementSerializer,
+    OccurrenceAddDetectionsSerializer,
+    OccurrenceFrameSerializer,
+    OccurrenceGroupingSerializer,
     OccurrenceListSerializer,
+    OccurrenceMergeSerializer,
+    OccurrencePathFrameSerializer,
     OccurrenceSerializer,
     PageListSerializer,
     PageSerializer,
@@ -103,6 +139,8 @@
     TaxonSearchResultSerializer,
     TaxonSerializer,
     TopIdentifiersResponseSerializer,
+    TrackEditResultSerializer,
+    TrackEditSerializer,
 )
 
 logger = logging.getLogger(__name__)
@@ -700,6 +738,7 @@ def get_queryset(self) -> QuerySet:
             queryset = queryset.prefetch_related("jobs", "collections")
             queryset = self.add_adjacent_captures(queryset)
             queryset = self.annotate_last_processed(queryset)
+            queryset = queryset.with_detections_with_features()  # type: ignore
             with_detections_default = True
 
         with_detections = self.request.query_params.get("with_detections", with_detections_default)
@@ -803,8 +842,7 @@ def prefetch_detections(self, queryset: QuerySet, project: Project | None = None
         score = get_default_classification_threshold(project, self.request)
 
         prefetch_queryset = (
-            Detection.objects.valid()
-            .annotate(
+            Detection.objects.valid().annotate(
                 determination_score=models.Max("occurrence__detections__classifications__score"),
                 # Store whether this occurrence should be included based on default filters
                 occurrence_meets_criteria=models.Case(
@@ -817,7 +855,17 @@ def prefetch_detections(self, queryset: QuerySet, project: Project | None = None
                 ),
                 score_threshold=models.Value(score, output_field=models.FloatField()),
             )
-            .select_related("occurrence", "occurrence__determination")
+            # Prefetch rather than select_related the occurrence: the session toolbar
+            # needs its detections_count to say "9 frames" or "one frame only" before
+            # asking for a path, and an annotation cannot ride along on a join.
+            .prefetch_related(
+                Prefetch(
+                    "occurrence",
+                    queryset=Occurrence.objects.with_detections_count().select_related(  # type: ignore
+                        "determination", "grouping_verified_by"
+                    ),
+                )
+            )
         )
 
         related_detections = Prefetch(
@@ -867,9 +915,34 @@ def add_adjacent_captures(self, queryset: QuerySet) -> QuerySet:
             .values("total")
         )
 
+        # Nearest capture on each side with a real box, by (timestamp, id), so a burst seconds apart
+        # is walked frame by frame. The gte + exclude tie-break lets the (event, timestamp) index walk
+        # stop at the first hit, where an OR of the two cases reads every capture on that side.
+        boxed_in_event = SourceImage.objects.filter(event=models.OuterRef("event")).filter(
+            models.Exists(Detection.objects.valid().filter(source_image_id=models.OuterRef("pk")))
+        )
+        next_with_detections = (
+            boxed_in_event.filter(timestamp__gte=models.OuterRef("timestamp"))
+            .exclude(timestamp=models.OuterRef("timestamp"), pk__lte=models.OuterRef("pk"))
+            .order_by("timestamp", "pk")
+            .values("id")[:1]
+        )
+        prev_with_detections = (
+            boxed_in_event.filter(timestamp__lte=models.OuterRef("timestamp"))
+            .exclude(timestamp=models.OuterRef("timestamp"), pk__gte=models.OuterRef("pk"))
+            .order_by("-timestamp", "-pk")
+            .values("id")[:1]
+        )
+
         return queryset.annotate(
             event_next_capture_id=models.Subquery(next_image, output_field=models.IntegerField()),
             event_prev_capture_id=models.Subquery(previous_image, output_field=models.IntegerField()),
+            event_next_capture_with_detections_id=models.Subquery(
+                next_with_detections, output_field=models.IntegerField()
+            ),
+            event_prev_capture_with_detections_id=models.Subquery(
+                prev_with_detections, output_field=models.IntegerField()
+            ),
             event_current_capture_index=models.Subquery(index_subquery, output_field=models.IntegerField()),
             event_total_captures=models.Subquery(total_subquery, output_field=models.IntegerField()),
         )
@@ -1214,6 +1287,10 @@ def get_queryset(self) -> QuerySet:
         project = self.get_active_project()
         if project:
             qs = qs.filter(source_image__project=project)
+        if self.action == "retrieve":
+            # The detail serializer nests classifications; the prefetch the occurrence
+            # detail uses joins their relations and annotates has_features.
+            qs = qs.prefetch_related(prefetch_nested_classifications())
         return qs
 
     @extend_schema(parameters=[project_id_doc_param])
@@ -1362,6 +1439,30 @@ def filter_queryset(self, request: Request, queryset, view):
         return queryset
 
 
+class OccurrenceGroupingVerifiedFilter(filters.BaseFilterBackend):
+    """Filter occurrences by whether a person has confirmed how their detections are grouped.
+
+    Absent leaves every occurrence in, true keeps only confirmed tracks and false only
+    unconfirmed ones. An unparseable value is a 400 rather than a silent "unconfirmed".
+    """
+
+    query_param = "grouping_verified"
+
+    def filter_queryset(self, request: Request, queryset, view):
+        # A boolean field reads a parameter missing from a query string as False, so the
+        # presence check is what keeps an absent parameter meaning "leave both in".
+        if self.query_param not in request.query_params:
+            return queryset
+        grouping_verified: bool | None = SingleParamSerializer[bool].clean(
+            param_name=self.query_param,
+            field=serializers.BooleanField(required=False, allow_null=True),
+            data=request.query_params,
+        )
+        if grouping_verified is None:
+            return queryset
+        return queryset.filter(grouping_verified_at__isnull=not grouping_verified)
+
+
 class DateRangeFilterSerializer(FilterParamsSerializer):
     date_start = serializers.DateField(required=False)
     date_end = serializers.DateField(required=False)
@@ -1455,6 +1556,7 @@ def filter_queryset(self, request, queryset, view):
     OccurrenceDateFilter,
     OccurrenceVerified,
     OccurrenceVerifiedByMeFilter,
+    OccurrenceGroupingVerifiedFilter,
     OccurrenceTaxaListFilter,
 )
 
@@ -1481,6 +1583,36 @@ class Meta:
         fields = list(OCCURRENCE_FILTERSET_FIELDS)
 
 
+class OccurrenceFramesPagination(LimitOffsetPaginationWithPermissions):
+    """Pages of one occurrence's frames. The view sets ``around_index`` to open the
+    page that holds a given frame, instead of reading ``offset``."""
+
+    default_limit = OCCURRENCE_FRAMES_PAGE_SIZE
+    max_limit = 200
+    around_index: int | None = None
+
+    def get_offset(self, request):
+        if self.around_index is not None:
+            return (self.around_index // self.limit) * self.limit
+        return super().get_offset(request)
+
+    # The neighbouring pages are addressed by offset alone; kept, `around` would win.
+    def get_next_link(self):
+        url = super().get_next_link()
+        return remove_query_param(url, "around") if url else url
+
+    def get_previous_link(self):
+        url = super().get_previous_link()
+        return remove_query_param(url, "around") if url else url
+
+
+class SessionBusyConflict(api_exceptions.APIException):
+    """A track edit refused because a tracking run holds the session; the client can retry."""
+
+    status_code = status.HTTP_409_CONFLICT
+    default_code = "session_busy"
+
+
 class OccurrenceViewSet(DefaultViewSet, ProjectMixin):
     """
     API endpoint that allows occurrences to be viewed or edited.
@@ -1505,6 +1637,11 @@ class OccurrenceViewSet(DefaultViewSet, ProjectMixin):
         "determination_score",
         "event",
         "detections_count",
+        # Stored by models_future.track_stats.refresh_track_stats; null rows sort last.
+        "track_motion",
+        "track_size_ratio",
+        "track_distinct_taxa",
+        "track_id_agreement",
     ]
 
     def get_serializer_class(self):
@@ -1516,9 +1653,40 @@ def get_serializer_class(self):
         else:
             return OccurrenceSerializer
 
+    # Actions that repair how detections are grouped, rather than show occurrences.
+    # They reach past both viewing filters; see get_queryset.
+    TRACK_EDIT_ACTIONS = (
+        "merge_candidates",
+        "capture_matches",
+        "merge",
+        "add_detections",
+        "split_track",
+        "remove_detection",
+        "verify_grouping",
+        "unverify_grouping",
+    )
+    # Actions that open one occurrence. They drop the determination requirement; see
+    # get_queryset.
+    SINGLE_OCCURRENCE_ACTIONS = ("retrieve", "path", "detections")
+    # Actions the project's default filters never hide an occurrence from. The session
+    # view selects occurrences with those filters off and draws their paths.
+    UNFILTERED_ACTIONS = (*TRACK_EDIT_ACTIONS, "path")
+
     def get_queryset(self) -> QuerySet["Occurrence"]:
+        """Occurrences this request may see, which is wider outside the list.
+
+        The list shows determined occurrences that pass the project's default filters.
+        Opening one occurrence keeps those filters but not the determination, and
+        reading or repairing a track keeps neither. On a project where only a detector
+        ran every occurrence is undetermined until a person identifies it, and a
+        low-score or excluded-taxon occurrence is still part of the animal's track. See
+        OccurrenceQuerySet.with_real_detections.
+        """
         project = self.get_active_project()
-        qs = super().get_queryset().valid()  # type: ignore
+        track_edit = self.action in self.TRACK_EDIT_ACTIONS
+        allow_undetermined = track_edit or self.action in self.SINGLE_OCCURRENCE_ACTIONS
+        qs = super().get_queryset()
+        qs = qs.with_real_detections() if allow_undetermined else qs.valid()  # type: ignore
         if project:
             qs = qs.filter(project=project)
         qs = qs.select_related(
@@ -1527,11 +1695,19 @@ def get_queryset(self) -> QuerySet["Occurrence"]:
             "event",
         )
         qs = qs.with_detections_count().with_timestamps()  # type: ignore
-        qs = qs.with_identifications()  # type: ignore
-        qs = qs.apply_default_filters(project, self.request)  # type: ignore
+        if self.action != "detections":
+            qs = qs.with_identifications()  # type: ignore
+        if self.action not in self.UNFILTERED_ACTIONS:
+            qs = qs.apply_default_filters(  # type: ignore
+                project, self.request, include_undetermined=allow_undetermined
+            )
         if self.action == "list":
             qs = qs.with_list_prefetches()  # type: ignore
-        else:
+        elif self.action not in ("path", "detections", "merge_candidates", "capture_matches"):
+            # `path` and the track-edit pickers build their own values() queries and never
+            # serialize the occurrence, so the detail prefetch would only be waste:
+            # measured at 249ms/4 queries against 6ms/2 for the same object without
+            # it, on a 37-detection occurrence.
             qs = qs.with_detail_prefetches()  # type: ignore
 
         return qs
@@ -1558,11 +1734,410 @@ def get_queryset(self) -> QuerySet["Occurrence"]:
                 required=False,
                 type=OpenApiTypes.INT,
             ),
+            OpenApiParameter(
+                name="grouping_verified",
+                description="Filter occurrences by whether a person has confirmed how their detections are "
+                "grouped into a track. Omit to show both.",
+                required=False,
+                type=OpenApiTypes.BOOL,
+            ),
         ]
     )
     def list(self, request, *args, **kwargs):
         return super().list(request, *args, **kwargs)
 
+    @extend_schema(
+        parameters=[project_id_doc_param],
+        responses=OccurrencePathFrameSerializer(many=True),
+    )
+    @action(detail=True, methods=["get"], name="path")
+    def path(self, request: Request, pk=None) -> Response:
+        """Where this occurrence was in every frame it appears in, earliest first.
+
+        Enough to draw the whole path of one animal over any single capture of the
+        session: each frame's box plus the dimensions of the capture that box was
+        measured against, which no other payload carries. Reading a grouping from
+        the frame is what makes a wrong merge visible, since two individuals of the
+        same species are indistinguishable as cropped thumbnails.
+
+        Fetched on request rather than with the session, because a session holds
+        thousands of occurrences and an operator looks at one.
+        """
+        occurrence = self.get_object()
+        return Response(OccurrencePathFrameSerializer(occurrence_path(occurrence), many=True).data)
+
+    @extend_schema(
+        parameters=[
+            project_id_doc_param,
+            OpenApiParameter(
+                name="around",
+                description="A detection of this occurrence. Returns the page that holds it, " "in place of `offset`.",
+                required=False,
+                type=OpenApiTypes.INT,
+            ),
+        ],
+        responses=OccurrenceFrameSerializer(many=True),
+    )
+    @action(detail=True, methods=["get"], name="detections", pagination_class=OccurrenceFramesPagination)
+    def detections(self, request: Request, pk=None) -> Response:
+        """This occurrence's detections one page at a time, in capture order.
+
+        A track can hold hundreds of frames, too many to embed in the detail
+        response, which carries only the first page. ``frame_index`` is each
+        detection's position in the whole track, so pages can be labelled and
+        jumped between without loading the others.
+        """
+        occurrence = self.get_object()
+        params = request.query_params
+        SingleParamSerializer[int].clean(
+            param_name="limit",
+            field=serializers.IntegerField(
+                required=False, min_value=1, max_value=OccurrenceFramesPagination.max_limit
+            ),
+            data=params,
+        )
+        SingleParamSerializer[int].clean(
+            param_name="offset", field=serializers.IntegerField(required=False, min_value=0), data=params
+        )
+        around = SingleParamSerializer[int].clean(
+            param_name="around", field=serializers.IntegerField(required=False, min_value=1), data=params
+        )
+        if around is not None and "offset" in params:
+            raise api_exceptions.ValidationError({"around": "Pass either `around` or `offset`, not both."})
+
+        frame_order = [F(field) if isinstance(field, str) else field for field in CAPTURE_ORDER]
+        if around is not None:
+            ordered_ids = list(occurrence.detections.order_by(*frame_order).values_list("pk", flat=True))
+            if around not in ordered_ids:
+                raise api_exceptions.ValidationError({"around": f"Detection {around} is not in this occurrence."})
+            self.paginator.around_index = ordered_ids.index(around)
+
+        frames = (
+            Detection.objects.filter(occurrence=occurrence)
+            .select_related("source_image__deployment__data_source")
+            .prefetch_related(prefetch_nested_classifications())
+            .annotate(frame_index=Window(RowNumber(), order_by=frame_order) - 1)
+            .order_by(*frame_order)
+        )
+        page = self.paginate_queryset(frames)
+        serializer = OccurrenceFrameSerializer(page, many=True, context=self.get_serializer_context())
+        return self.get_paginated_response(serializer.data)
+
+    def get_permissions(self):
+        # The viewset as a whole is staff-only for writes. Track edits are the
+        # exception: they are a curation tool, gated per object by
+        # Occurrence.check_custom_permission on the project's occurrence rights,
+        # and only on projects that have opted into tracking.
+        if self.action in self.TRACK_EDIT_ACTIONS:
+            return [ObjectPermission(), TrackingEnabled()]
+        return super().get_permissions()
+
+    def _detection_in_track(self, request: Request, occurrence: Occurrence) -> Detection:
+        """Resolve the detection named in the request body, or raise a 400."""
+        body = TrackEditSerializer(data=request.data)
+        body.is_valid(raise_exception=True)
+        detection = occurrence.detections.filter(pk=body.validated_data["detection_id"]).first()
+        if detection is None:
+            raise api_exceptions.ValidationError(
+                {"detection_id": f"Detection {body.validated_data['detection_id']} is not in this occurrence."}
+            )
+        return detection
+
+    @staticmethod
+    def _track_edit_response(occurrence: Occurrence, new_occurrence: Occurrence) -> Response:
+        # Count against the database rather than occurrence.detections: the detail
+        # queryset prefetches the detections, and the related manager answers .count()
+        # from that cache, which still holds the detections the edit just moved away.
+        counts = dict(
+            Detection.objects.filter(occurrence_id__in=[occurrence.pk, new_occurrence.pk])
+            .values_list("occurrence_id")
+            .annotate(total=models.Count("pk"))
+        )
+        return Response(
+            TrackEditResultSerializer(
+                {
+                    "occurrence_id": occurrence.pk,
+                    "occurrence_detections_count": counts.get(occurrence.pk, 0),
+                    "new_occurrence_id": new_occurrence.pk,
+                    "new_occurrence_detections_count": counts.get(new_occurrence.pk, 0),
+                }
+            ).data
+        )
+
+    @extend_schema(request=TrackEditSerializer, responses=TrackEditResultSerializer)
+    @action(detail=True, methods=["post"], name="split-track", url_path="split-track")
+    def split_track(self, request: Request, pk=None) -> Response:
+        """Split this occurrence at a detection: that detection and every later one move to a new occurrence.
+
+        Use when tracking ran two insects together and you can point at the frame
+        where the second one takes over.
+        """
+        occurrence = self.get_object()
+        detection = self._detection_in_track(request, occurrence)
+        try:
+            new_occurrence = split_track(occurrence, detection)
+        except SessionBusy as e:
+            raise SessionBusyConflict(str(e))
+        except TrackEditError as e:
+            raise api_exceptions.ValidationError({"detection_id": str(e)})
+        return self._track_edit_response(occurrence, new_occurrence)
+
+    @extend_schema(request=TrackEditSerializer, responses=TrackEditResultSerializer)
+    @action(detail=True, methods=["post"], name="remove-detection", url_path="remove-detection")
+    def remove_detection(self, request: Request, pk=None) -> Response:
+        """Move one detection out of this occurrence into an occurrence of its own.
+
+        The rest of the track is stitched back together, so removing a frame from
+        the middle does not also split what remains.
+        """
+        occurrence = self.get_object()
+        detection = self._detection_in_track(request, occurrence)
+        try:
+            new_occurrence = detach_detection(occurrence, detection)
+        except SessionBusy as e:
+            raise SessionBusyConflict(str(e))
+        except TrackEditError as e:
+            raise api_exceptions.ValidationError({"detection_id": str(e)})
+        return self._track_edit_response(occurrence, new_occurrence)
+
+    @staticmethod
+    def _grouping_response(occurrence: Occurrence) -> Response:
+        occurrence.refresh_from_db()
+        verified_by = occurrence.grouping_verified_by
+        return Response(
+            OccurrenceGroupingSerializer(
+                {
+                    "occurrence_id": occurrence.pk,
+                    "detections_count": occurrence.detections.count(),
+                    "grouping_verified": occurrence.grouping_verified,
+                    "grouping_verified_at": occurrence.grouping_verified_at,
+                    "grouping_verified_by": verified_by.name if verified_by else None,
+                }
+            ).data
+        )
+
+    @extend_schema(request=OccurrenceMergeSerializer, responses=OccurrenceGroupingSerializer)
+    @action(detail=True, methods=["post"], name="merge")
+    def merge(self, request: Request, pk=None) -> Response:
+        """Fold other occurrences into this one: one animal that tracking recorded as several.
+
+        Their detections and identifications move here and the emptied occurrences
+        are removed. All of them must belong to this occurrence's session.
+        """
+        occurrence = self.get_object()
+        body = OccurrenceMergeSerializer(data=request.data)
+        body.is_valid(raise_exception=True)
+        requested = body.validated_data["occurrence_ids"]
+        sources = list(self.get_queryset().filter(pk__in=requested))
+        missing = sorted(set(requested) - {o.pk for o in sources} - {occurrence.pk})
+        if missing:
+            raise api_exceptions.ValidationError({"occurrence_ids": f"Occurrence(s) {missing} were not found."})
+        try:
+            merge_occurrences(occurrence, sources)
+        except SessionBusy as e:
+            raise SessionBusyConflict(str(e))
+        except TrackEditError as e:
+            raise api_exceptions.ValidationError({"occurrence_ids": str(e)})
+        return self._grouping_response(occurrence)
+
+    @extend_schema(
+        parameters=[
+            project_id_doc_param,
+            OpenApiParameter(
+                name="captures",
+                description=f"How many captures before this occurrence's first frame and after its last frame "
+                f"to search, besides the captures inside its span, 1 to {MAX_ADJACENT_CAPTURES}. Default "
+                f"{DEFAULT_ADJACENT_CAPTURES}. Cannot be combined with `minutes`.",
+                required=False,
+                type=OpenApiTypes.INT,
+            ),
+            OpenApiParameter(
+                name="minutes",
+                description=f"Search from this many minutes before this occurrence's first frame to this many "
+                f"minutes after its last, instead of the adjacent captures, 1 to {MAX_WINDOW_MINUTES}. Cannot be "
+                "combined with `captures`.",
+                required=False,
+                type=OpenApiTypes.INT,
+            ),
+            OpenApiParameter(
+                name="detection",
+                description="Rank other occurrences as destinations for this one detection of the occurrence, "
+                "scored from that detection alone, instead of as merges for the whole occurrence.",
+                required=False,
+                type=OpenApiTypes.INT,
+            ),
+        ],
+        responses=MergeCandidatesResponseSerializer,
+    )
+    @action(detail=True, methods=["get"], name="merge-candidates", url_path="merge-candidates")
+    def merge_candidates(self, request: Request, pk=None) -> Response:
+        """Occurrences of this session that this one could be merged with, best fit first.
+
+        Searches the captures adjacent to this occurrence, or a time window around it,
+        and ranks what it finds by the tracking method's matching cost between the two
+        frames nearest in time, so the occurrence tracking most nearly linked comes
+        first. Candidates before or after this occurrence are ranked together with
+        those in a gap of it, on captures inside its span that it has no frame on.
+        Occurrences with a frame on one of its captures are other animals and are left
+        out. Drawn from the same queryset the merge action resolves its sources from,
+        so everything offered here can be merged.
+
+        With `detection`, ranks the destinations for moving that one detection instead,
+        searching and scoring from it alone.
+        """
+        occurrence = self.get_object()
+        # Candidates are found by session, and event_id=None would match every ungrouped capture.
+        try:
+            refuse_edit_outside_session(occurrence)
+        except TrackEditError as e:
+            raise api_exceptions.ValidationError({"occurrence": str(e)})
+        if "captures" in request.query_params and "minutes" in request.query_params:
+            raise api_exceptions.ValidationError(
+                {"minutes": "Pass either `captures` or `minutes` to choose where to search, not both."}
+            )
+        captures = SingleParamSerializer[int].clean(
+            param_name="captures",
+            field=serializers.IntegerField(
+                required=False, min_value=1, max_value=MAX_ADJACENT_CAPTURES, default=DEFAULT_ADJACENT_CAPTURES
+            ),
+            data=request.query_params,
+        )
+        minutes = SingleParamSerializer[int].clean(
+            param_name="minutes",
+            field=serializers.IntegerField(required=False, min_value=1, max_value=MAX_WINDOW_MINUTES),
+            data=request.query_params,
+        )
+        detection_id = SingleParamSerializer[int].clean(
+            param_name="detection",
+            field=serializers.IntegerField(required=False, min_value=1),
+            data=request.query_params,
+        )
+        try:
+            candidates = rank_merge_candidates(
+                occurrence,
+                self.get_queryset().prefetch_related(None),
+                minutes=minutes,
+                captures=captures,
+                detection_id=detection_id,
+            )
+        except DetectionNotInOccurrence:
+            raise api_exceptions.ValidationError({"detection": "Not a detection of this occurrence."})
+        config = tracking_config_for(occurrence)
+        return Response(
+            MergeCandidatesResponseSerializer(
+                {
+                    "candidates": candidates,
+                    "cost_threshold": config.cost_threshold,
+                    "requires_features": config.require_features,
+                }
+            ).data
+        )
+
+    @extend_schema(
+        parameters=[
+            project_id_doc_param,
+            OpenApiParameter(
+                name="capture_id",
+                description="The capture whose boxes to score. Must belong to this occurrence's session.",
+                required=True,
+                type=OpenApiTypes.INT,
+            ),
+        ],
+        responses=CaptureMatchesResponseSerializer,
+    )
+    @action(detail=True, methods=["get"], name="capture-matches", url_path="capture-matches")
+    def capture_matches(self, request: Request, pk=None) -> Response:
+        """How likely each box on one capture of the session is to be this occurrence's animal.
+
+        For extending a track capture by capture: every real box on the capture, grouped
+        or not, is scored with the tracking method's matching cost against the track
+        frame nearest in time on another capture, and the cost is read as a likelihood
+        that is comparable from one capture to the next. The query count is fixed, so it
+        can run on every step.
+        """
+        occurrence = self.get_object()
+        capture_id = SingleParamSerializer[int].clean(
+            param_name="capture_id",
+            field=serializers.IntegerField(required=True, min_value=1),
+            data=request.query_params,
+        )
+        # Ungrouped captures are excluded first, since event_id=None would match all of them.
+        try:
+            capture = (
+                SourceImage.objects.exclude(event=None)
+                .only("pk", "timestamp", "width", "height")
+                .get(pk=capture_id, event_id=occurrence.event_id)
+            )
+        except SourceImage.DoesNotExist:
+            raise api_exceptions.ValidationError({"capture_id": "Not a capture of this occurrence's session."})
+        return Response(CaptureMatchesResponseSerializer(match_capture_detections(occurrence, capture)).data)
+
+    @extend_schema(request=OccurrenceAddDetectionsSerializer, responses=OccurrenceGroupingSerializer)
+    @action(detail=True, methods=["post"], name="add-detections", url_path="add-detections")
+    def add_detections(self, request: Request, pk=None) -> Response:
+        """Move individual detections into this occurrence.
+
+        Use when a frame belongs to this animal but was left on its own, attached to
+        the wrong occurrence, or never grouped into one at all. An occurrence emptied
+        by the move is absorbed, so identifications on it are kept.
+        """
+        occurrence = self.get_object()
+        body = OccurrenceAddDetectionsSerializer(data=request.data)
+        body.is_valid(raise_exception=True)
+        requested = body.validated_data["detection_ids"]
+        # Scoped through the capture rather than the occurrence: a detection that was
+        # never grouped has no occurrence to read a project from, and those are the
+        # ones a hand-built track is assembled from.
+        detections = list(
+            Detection.objects.valid()
+            .filter(pk__in=requested, source_image__project=occurrence.project)
+            .select_related("source_image")
+        )
+        missing = sorted(set(requested) - {d.pk for d in detections})
+        if missing:
+            raise api_exceptions.ValidationError(
+                {"detection_ids": f"Detection(s) {missing} were not found in this project."}
+            )
+        try:
+            add_detections(occurrence, detections)
+        except SessionBusy as e:
+            raise SessionBusyConflict(str(e))
+        except TrackEditError as e:
+            raise api_exceptions.ValidationError({"detection_ids": str(e)})
+        return self._grouping_response(occurrence)
+
+    @extend_schema(request=None, responses=OccurrenceGroupingSerializer)
+    @action(detail=True, methods=["post"], name="verify-grouping", url_path="verify-grouping")
+    def verify_grouping(self, request: Request, pk=None) -> Response:
+        """Confirm that this occurrence holds the right detections.
+
+        Separate from identifying the taxon. Confirmed occurrences are the ground
+        truth the tracking methods are measured against, so this is only ever set
+        deliberately — no other operation sets it as a side effect, and any later
+        change to the detections clears it.
+        """
+        occurrence = self.get_object()
+        try:
+            verify_grouping(occurrence, request.user)
+        except SessionBusy as e:
+            raise SessionBusyConflict(str(e))
+        except TrackEditError as e:
+            raise api_exceptions.ValidationError(str(e))
+        return self._grouping_response(occurrence)
+
+    @extend_schema(request=None, responses=OccurrenceGroupingSerializer)
+    @action(detail=True, methods=["post"], name="unverify-grouping", url_path="unverify-grouping")
+    def unverify_grouping(self, request: Request, pk=None) -> Response:
+        """Withdraw a previous confirmation. The detections are left untouched."""
+        occurrence = self.get_object()
+        try:
+            unverify_grouping(occurrence)
+        except SessionBusy as e:
+            raise SessionBusyConflict(str(e))
+        except TrackEditError as e:
+            raise api_exceptions.ValidationError(str(e))
+        return self._grouping_response(occurrence)
+
     @extend_schema(parameters=[project_id_doc_param], responses=AlgorithmSerializer(many=True))
     @action(detail=False, methods=["get"], name="algorithms")
     def algorithms(self, request: Request) -> Response:
diff --git a/ami/main/management/commands/backfill_track_stats.py b/ami/main/management/commands/backfill_track_stats.py
new file mode 100644
index 000000000..ccf962f69
--- /dev/null
+++ b/ami/main/management/commands/backfill_track_stats.py
@@ -0,0 +1,61 @@
+"""
+Store track statistics on the occurrences of one project.
+
+Tracking and the track edits keep ``Occurrence.track_*`` current from the moment the
+fields exist; this fills in the rows from before that, so the occurrence list can sort
+every row by motion, size change and identification agreement. Multi-frame occurrences
+are the ones worth sorting by, so single-frame ones are skipped unless asked for.
+
+Safe to re-run: every pass recomputes from the current detections. ``updated_at`` is
+left alone, so the default list order does not change.
+"""
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db.models import Count
+
+from ami.main.models import Occurrence, Project
+from ami.main.models_future.track_stats import REFRESH_BATCH_SIZE, refresh_track_stats_for_ids
+
+
+class Command(BaseCommand):
+    help = "Store track statistics (motion, size ratio, distinct taxa, id agreement) on a project's occurrences."
+
+    def add_arguments(self, parser):
+        parser.add_argument("--project", type=int, required=True, help="Project ID to backfill.")
+        parser.add_argument(
+            "--only-multi-frame",
+            action="store_true",
+            default=True,
+            help="Skip occurrences with a single detection (default).",
+        )
+        parser.add_argument(
+            "--all-occurrences",
+            action="store_false",
+            dest="only_multi_frame",
+            help="Include single-detection occurrences as well.",
+        )
+
+    def handle(self, *args, **options):
+        project_id: int = options["project"]
+        only_multi_frame: bool = options["only_multi_frame"]
+
+        try:
+            project = Project.objects.get(pk=project_id)
+        except Project.DoesNotExist as err:
+            raise CommandError(f"Project {project_id} does not exist") from err
+
+        occurrences = Occurrence.objects.filter(project=project)
+        if only_multi_frame:
+            occurrences = occurrences.annotate(frame_count=Count("detections")).filter(frame_count__gt=1)
+
+        # Materialize the ids first: the refresh writes to the same rows the filter reads.
+        ids = list(occurrences.order_by("pk").values_list("pk", flat=True))
+        scope = "multi-frame occurrences" if only_multi_frame else "occurrences"
+        self.stdout.write(f"Project #{project.pk} ({project.name}): {len(ids)} {scope} to refresh.")
+
+        refreshed = 0
+        for start in range(0, len(ids), REFRESH_BATCH_SIZE):
+            refreshed += refresh_track_stats_for_ids(ids[start : start + REFRESH_BATCH_SIZE])
+            self.stdout.write(f"  {refreshed}/{len(ids)}")
+
+        self.stdout.write(self.style.SUCCESS(f"Stored track statistics for {refreshed} {scope}."))
diff --git a/ami/main/management/commands/create_demo_project.py b/ami/main/management/commands/create_demo_project.py
index f715d8de0..de97933f6 100644
--- a/ami/main/management/commands/create_demo_project.py
+++ b/ami/main/management/commands/create_demo_project.py
@@ -1,3 +1,5 @@
+import json
+import pathlib
 import time
 
 from django.core.management.base import BaseCommand
@@ -5,6 +7,7 @@
 from ami.main.models import Deployment, Detection, Device, Event, Occurrence, Project, SourceImage, TaxaList, Taxon
 from ami.ml.models import Algorithm, Pipeline
 from ami.tests.fixtures.main import create_complete_test_project, create_local_admin_user
+from ami.tests.fixtures.tracking import DEFAULT_MOTION_SCALE, DEFAULT_SEED, TrackingSessionGroundTruth
 
 
 class Command(BaseCommand):
@@ -19,6 +22,51 @@ def add_arguments(self, parser):
             action="store_true",
             help="Delete existing data before creating new demo project",
         )
+        parser.add_argument(
+            "--no-tracking-session",
+            action="store_false",
+            dest="tracking_session",
+            help="Skip the extra capture session built for occurrence tracking",
+        )
+        parser.add_argument(
+            "--tracking-frames",
+            type=int,
+            default=24,
+            help="Number of consecutive captures in the tracking session (default: 24)",
+        )
+        parser.add_argument(
+            "--tracking-interval-minutes",
+            type=int,
+            default=2,
+            help="Minutes between captures in the tracking session (default: 2)",
+        )
+        parser.add_argument(
+            "--tracking-motion-scale",
+            type=float,
+            default=DEFAULT_MOTION_SCALE,
+            help=(
+                "How far a simulated insect drifts between captures. Raise it above the default of "
+                f"{DEFAULT_MOTION_SCALE} to make the session harder to track"
+            ),
+        )
+        parser.add_argument(
+            "--no-features",
+            action="store_false",
+            dest="with_features",
+            help="Skip the synthetic feature embeddings, leaving tracking to match on geometry alone",
+        )
+        parser.add_argument(
+            "--seed",
+            type=int,
+            default=DEFAULT_SEED,
+            help=f"Random seed for the tracking session (default: {DEFAULT_SEED})",
+        )
+        parser.add_argument(
+            "--ground-truth-output",
+            type=str,
+            default=None,
+            help="Write the tracking session's ground-truth grouping to this JSON file",
+        )
 
     def handle(self, *args, **options):
         if options["delete"]:
@@ -42,4 +90,51 @@ def handle(self, *args, **options):
 
         self.stdout.write("Creating test project")
         create_local_admin_user()
-        create_complete_test_project()
+        tracking_kwargs = {}
+        if options["tracking_session"]:
+            tracking_kwargs = dict(
+                num_frames=options["tracking_frames"],
+                minutes_interval=options["tracking_interval_minutes"],
+                motion_scale=options["tracking_motion_scale"],
+                with_features=options["with_features"],
+                seed=options["seed"],
+            )
+        project, ground_truth = create_complete_test_project(
+            with_tracking_session=options["tracking_session"], **tracking_kwargs
+        )
+        self.stdout.write(self.style.SUCCESS(f"Created project #{project.pk} {project.name}"))
+
+        if ground_truth:
+            self.report_tracking_session(ground_truth)
+            if options["ground_truth_output"]:
+                path = pathlib.Path(options["ground_truth_output"])
+                path.write_text(json.dumps(ground_truth.as_dict(), indent=2))
+                self.stdout.write(f"Wrote the full detection-to-insect mapping to {path}")
+
+    def report_tracking_session(self, ground_truth: TrackingSessionGroundTruth) -> None:
+        """Print what a tracking run over this session is expected to find."""
+        self.stdout.write("")
+        self.stdout.write(self.style.SUCCESS("Tracking session"))
+        self.stdout.write(f"  Event:       {ground_truth.event_id}")
+        self.stdout.write(f"  Capture set: {ground_truth.capture_set_id}")
+        self.stdout.write(f"  Captures:    {ground_truth.capture_count}")
+        self.stdout.write(
+            f"  Detections:  {ground_truth.detection_count}, one occurrence each, the way a pipeline leaves them"
+        )
+        self.stdout.write(f"  Seed:        {ground_truth.seed}")
+        if ground_truth.feature_algorithm_key:
+            self.stdout.write(f"  Embeddings:  from algorithm '{ground_truth.feature_algorithm_key}'")
+        else:
+            self.stdout.write("  Embeddings:  none, so track with require_features=False")
+        self.stdout.write("")
+        self.stdout.write("  Simulated insect  Species                Frames     Detections")
+        for insect in ground_truth.insects:
+            frames = f"{min(insect.frame_numbers)}-{max(insect.frame_numbers)}"
+            self.stdout.write(
+                f"  {insect.identifier:<17} {insect.taxon_name:<22} {frames:<10} {len(insect.detection_ids)}"
+            )
+        self.stdout.write("")
+        self.stdout.write(
+            f"  A perfect run leaves {len(ground_truth.insects)} occurrences, the longest spanning "
+            f"{ground_truth.chain_lengths[0]} detections."
+        )
diff --git a/ami/main/management/commands/evaluate_tracking.py b/ami/main/management/commands/evaluate_tracking.py
new file mode 100644
index 000000000..4ca6ff9a1
--- /dev/null
+++ b/ami/main/management/commands/evaluate_tracking.py
@@ -0,0 +1,195 @@
+"""
+Score occurrence tracking against the tracks people have confirmed in one project.
+
+Ground truth is every occurrence whose grouping a person confirmed. Predictions come from
+re-running the tracking link step over the raw detections of those sessions, as if none were
+linked yet, with the tunables given here. Nothing is written: the command runs inside a
+transaction that is always rolled back. See docs/claude/reference/tracking-evaluation.md.
+"""
+
+import json
+import logging
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+
+from ami.main.models import Detection, Event, Project
+from ami.ml.post_processing.tracking_evaluation import (
+    REPORT_NOTES,
+    ConfirmedSetBias,
+    TrackingEvaluation,
+    describe_confirmed_set,
+    evaluate_tracks,
+    tracks_from_links,
+)
+from ami.ml.post_processing.tracking_task import TrackingConfig, propose_event_links, resolve_feature_algorithm
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Score tracking against the confirmed tracks of a project, without writing anything."
+
+    def add_arguments(self, parser):
+        parser.add_argument("--project", type=int, required=True, help="Project ID.")
+        parser.add_argument(
+            "--event",
+            type=int,
+            action="append",
+            dest="events",
+            help="Session (event) ID to score; repeat for several. Default: every session with a confirmed track.",
+        )
+        defaults = TrackingConfig(event_ids=[0])
+        parser.add_argument("--cost-threshold", type=float, default=defaults.cost_threshold)
+        parser.add_argument("--require-features", dest="require_features", action="store_true")
+        parser.add_argument("--no-require-features", dest="require_features", action="store_false")
+        parser.set_defaults(require_features=defaults.require_features)
+        parser.add_argument(
+            "--feature-extraction-algorithm",
+            type=int,
+            default=None,
+            help="Algorithm ID whose embeddings to compare. Default: the only one in the session.",
+        )
+        parser.add_argument("--format", choices=["text", "json"], default="text")
+        parser.add_argument("--per-track", action="store_true", help="Include per-track scores in JSON output.")
+
+    def handle(self, *args, **options):
+        # Proposing links only reads, but the rollback guarantees a scoring run never changes data.
+        with transaction.atomic():
+            try:
+                report = self._evaluate(options)
+            finally:
+                transaction.set_rollback(True)
+
+        if options["format"] == "json":
+            public = {key: value for key, value in report.items() if not key.startswith("_")}
+            self.stdout.write(json.dumps(public, indent=2, default=str))
+        else:
+            self.stdout.write(self._as_text(report))
+
+    def _evaluate(self, options) -> dict:
+        project = Project.objects.filter(pk=options["project"]).first()
+        if project is None:
+            raise CommandError(f"Project {options['project']} not found.")
+
+        detections = Detection.objects.valid().filter(
+            source_image__project=project,
+            occurrence__project=project,
+            occurrence__grouping_verified_at__isnull=False,
+        )
+        if options["events"]:
+            detections = detections.filter(source_image__event_id__in=options["events"])
+        rows = list(detections.values_list("pk", "occurrence_id", "source_image__timestamp", "source_image__event_id"))
+
+        event_ids = sorted({row[3] for row in rows if row[3] is not None})
+        missing = sorted(set(options["events"] or []) - set(event_ids))
+        if missing:
+            logger.warning(f"No confirmed tracks in session(s) {missing} of project {project.pk}.")
+        if not event_ids:
+            raise CommandError(f"Project {project.pk} has no confirmed tracks in the sessions asked for.")
+
+        config = TrackingConfig(
+            event_ids=event_ids,
+            cost_threshold=options["cost_threshold"],
+            require_features=options["require_features"],
+            feature_extraction_algorithm_id=options["feature_extraction_algorithm"],
+        )
+
+        ground_truth: dict[int, int] = {}
+        timestamps: dict[int, object] = {}
+        predictions: dict[int, int] = {}
+        captures: dict[int, int] = {}
+        per_event: list[dict] = []
+        skipped: list[dict] = []
+        for event in Event.objects.filter(pk__in=event_ids).order_by("pk"):
+            event_rows = [row for row in rows if row[3] == event.pk]
+            algorithm, should_track, note = resolve_feature_algorithm(event, config)
+            if not should_track:
+                skipped.append({"event_id": event.pk, "reason": note, "confirmed_detections": len(event_rows)})
+                continue
+
+            links = propose_event_links(event, algorithm, config, logger)
+            event_captures = dict(
+                Detection.objects.valid().filter(source_image__event=event).values_list("pk", "source_image_id")
+            )
+            event_predictions = tracks_from_links(event_captures, [(a, b) for a, b, _ in links])
+            event_truth = {pk: occurrence_id for pk, occurrence_id, _, _ in event_rows}
+            event_times = {pk: timestamp for pk, _, timestamp, _ in event_rows}
+
+            missing_times = sorted(pk for pk, timestamp in event_times.items() if timestamp is None)
+            if missing_times:
+                raise CommandError(
+                    f"Session {event.pk} has {len(missing_times)} confirmed detection(s) on captures without "
+                    f"a timestamp, e.g. detection {missing_times[:3]}; they cannot be put in capture order."
+                )
+
+            ground_truth.update(event_truth)
+            timestamps.update(event_times)
+            predictions.update(event_predictions)
+            captures.update(event_captures)
+            per_event.append(
+                {
+                    "event_id": event.pk,
+                    "feature_extraction_algorithm_id": algorithm.pk if algorithm else None,
+                    "note": note,
+                    "links_proposed": len(links),
+                    "evaluation": evaluate_tracks(event_truth, event_predictions, event_times),
+                    "confirmed_vs_session": describe_confirmed_set(event_truth, event_predictions, event_captures),
+                }
+            )
+
+        overall: TrackingEvaluation | None = None
+        overall_bias: ConfirmedSetBias | None = None
+        if ground_truth:
+            overall = evaluate_tracks(ground_truth, predictions, timestamps)
+            overall_bias = describe_confirmed_set(ground_truth, predictions, captures)
+
+        per_track = options["per_track"]
+        return {
+            "project_id": project.pk,
+            "config": {
+                "cost_threshold": config.cost_threshold,
+                "require_features": config.require_features,
+                "feature_extraction_algorithm_id": config.feature_extraction_algorithm_id,
+            },
+            "events": [
+                {
+                    **entry,
+                    "evaluation": entry["evaluation"].to_dict(include_tracks=per_track),
+                    "confirmed_vs_session": entry["confirmed_vs_session"].to_dict(),
+                }
+                for entry in per_event
+            ],
+            "skipped_events": skipped,
+            "overall": overall.to_dict(include_tracks=per_track) if overall else None,
+            "confirmed_vs_session": overall_bias.to_dict() if overall_bias else None,
+            "_overall_lines": overall.summary_lines() + overall_bias.summary_lines()
+            if overall and overall_bias
+            else [],
+            "_event_lines": {
+                entry["event_id"]: entry["evaluation"].summary_lines() + entry["confirmed_vs_session"].summary_lines()
+                for entry in per_event
+            },
+        }
+
+    def _as_text(self, report: dict) -> str:
+        config = report["config"]
+        lines = [
+            f"Project {report['project_id']}: cost_threshold={config['cost_threshold']} "
+            f"require_features={config['require_features']} "
+            f"feature_extraction_algorithm_id={config['feature_extraction_algorithm_id']}",
+            *REPORT_NOTES,
+        ]
+        for entry in report["events"]:
+            lines.append("")
+            lines.append(f"Session {entry['event_id']} ({entry['links_proposed']} links proposed)")
+            if entry["note"]:
+                lines.append(f"  Note: {entry['note']}")
+            lines.extend(f"  {line}" for line in report["_event_lines"][entry["event_id"]])
+        for entry in report["skipped_events"]:
+            lines.append("")
+            lines.append(f"Session {entry['event_id']} skipped: {entry['reason']}")
+        lines.append("")
+        lines.append("Overall")
+        lines.extend(f"  {line}" for line in report["_overall_lines"] or ["No session could be scored."])
+        return "\n".join(lines)
diff --git a/ami/main/management/commands/export_tracks.py b/ami/main/management/commands/export_tracks.py
new file mode 100644
index 000000000..3cd301dd5
--- /dev/null
+++ b/ami/main/management/commands/export_tracks.py
@@ -0,0 +1,53 @@
+"""
+Write a project's tracks as CSV, one row per detection, for building and scoring a tracking benchmark.
+
+The columns are the ``tracks_csv`` export format's (``ami/exports/tracks.py``), so a file from
+this command and a file from the export API can be compared directly. Read-only.
+"""
+
+from django.core.management.base import BaseCommand, CommandError
+
+from ami.exports.tracks import write_tracks_csv
+from ami.main.models import Occurrence, Project
+
+
+class Command(BaseCommand):
+    help = "Write a project's tracks (one row per detection) as CSV to a file or stdout."
+
+    def add_arguments(self, parser):
+        parser.add_argument("--project", type=int, required=True, help="Project ID to export.")
+        parser.add_argument(
+            "--event",
+            type=int,
+            action="append",
+            dest="events",
+            default=[],
+            help="Only occurrences of this session (event) ID. Repeat to export several.",
+        )
+        parser.add_argument(
+            "--verified-only",
+            action="store_true",
+            help="Only occurrences whose grouping a reviewer has confirmed.",
+        )
+        parser.add_argument("--output", "-o", default="-", help="File path to write, or - for stdout (default).")
+
+    def handle(self, *args, **options):
+        project_id: int = options["project"]
+        if not Project.objects.filter(pk=project_id).exists():
+            raise CommandError(f"Project {project_id} does not exist")
+
+        occurrences = Occurrence.objects.with_real_detections()  # type: ignore[union-attr]
+        occurrences = occurrences.filter(project_id=project_id)
+        if options["events"]:
+            occurrences = occurrences.filter(event_id__in=options["events"])
+        if options["verified_only"]:
+            occurrences = occurrences.filter(grouping_verified_at__isnull=False)
+
+        output: str = options["output"]
+        if output == "-":
+            rows = write_tracks_csv(occurrences, self.stdout)
+        else:
+            with open(output, "w", newline="", encoding="utf-8") as stream:
+                rows = write_tracks_csv(occurrences, stream)
+        # Keep stdout pure CSV when the file goes there; the summary goes to stderr.
+        (self.stderr if output == "-" else self.stdout).write(f"Wrote {rows} detection rows.")
diff --git a/ami/main/migrations/0096_add_pgvector_extension.py b/ami/main/migrations/0096_add_pgvector_extension.py
new file mode 100644
index 000000000..836e28a77
--- /dev/null
+++ b/ami/main/migrations/0096_add_pgvector_extension.py
@@ -0,0 +1,18 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("main", "0095_grant_sync_deployment_to_mldatamanager"),
+    ]
+
+    operations = [
+        migrations.RunSQL(
+            # UPDATE brings an older installed extension up to the version the server ships;
+            # CREATE ... IF NOT EXISTS alone leaves it as it was.
+            sql="CREATE EXTENSION IF NOT EXISTS vector; ALTER EXTENSION vector UPDATE;",
+            # No-op on reverse: the extension may be shared with other features/databases,
+            # and dropping it can be restricted in some hosted environments.
+            reverse_sql=migrations.RunSQL.noop,
+        ),
+    ]
diff --git a/ami/main/migrations/0097_classification_features_2048.py b/ami/main/migrations/0097_classification_features_2048.py
new file mode 100644
index 000000000..6ff7a0bd7
--- /dev/null
+++ b/ami/main/migrations/0097_classification_features_2048.py
@@ -0,0 +1,20 @@
+from django.db import migrations
+import pgvector.django.vector
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("main", "0096_add_pgvector_extension"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="classification",
+            name="features_2048",
+            field=pgvector.django.vector.VectorField(
+                dimensions=2048,
+                null=True,
+                help_text="Feature embedding from the model backbone",
+            ),
+        ),
+    ]
diff --git a/ami/main/migrations/0098_detection_next_detection.py b/ami/main/migrations/0098_detection_next_detection.py
new file mode 100644
index 000000000..1f35abbc7
--- /dev/null
+++ b/ami/main/migrations/0098_detection_next_detection.py
@@ -0,0 +1,23 @@
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("main", "0097_classification_features_2048"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="detection",
+            name="next_detection",
+            field=models.OneToOneField(
+                blank=True,
+                help_text="The detection that follows this one in the tracking sequence.",
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="previous_detection",
+                to="main.detection",
+            ),
+        ),
+    ]
diff --git a/ami/main/migrations/0099_occurrence_grouping_verification.py b/ami/main/migrations/0099_occurrence_grouping_verification.py
new file mode 100644
index 000000000..b0445828a
--- /dev/null
+++ b/ami/main/migrations/0099_occurrence_grouping_verification.py
@@ -0,0 +1,31 @@
+# Generated by Django 4.2.10 on 2026-09-02 10:51
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("main", "0098_detection_next_detection"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="occurrence",
+            name="grouping_verified_at",
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="occurrence",
+            name="grouping_verified_by",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="verified_occurrence_groupings",
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+    ]
diff --git a/ami/main/migrations/0100_occurrence_track_stats.py b/ami/main/migrations/0100_occurrence_track_stats.py
new file mode 100644
index 000000000..570c0f5a7
--- /dev/null
+++ b/ami/main/migrations/0100_occurrence_track_stats.py
@@ -0,0 +1,51 @@
+# Generated by Django 4.2.10 on 2026-09-09 12:00
+#
+# Stored track statistics so the occurrence list can sort by them. No indexes: the list
+# is always filtered by project first, and the sort runs over that project's rows.
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("main", "0099_occurrence_grouping_verification"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="occurrence",
+            name="track_motion",
+            field=models.FloatField(
+                blank=True,
+                help_text="Path length between frames as a fraction of the frame diagonal. See models_future/track_stats.py.",
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name="occurrence",
+            name="track_size_ratio",
+            field=models.FloatField(
+                blank=True,
+                help_text="Largest box area over the smallest. See models_future/track_stats.py.",
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name="occurrence",
+            name="track_distinct_taxa",
+            field=models.IntegerField(
+                blank=True,
+                help_text="Distinct taxa among terminal classifications. See models_future/track_stats.py.",
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name="occurrence",
+            name="track_id_agreement",
+            field=models.FloatField(
+                blank=True,
+                help_text="Share of terminal classifications naming the determination. See models_future/track_stats.py.",
+                null=True,
+            ),
+        ),
+    ]
diff --git a/ami/main/migrations/0101_grant_run_post_processing_to_ml_data_manager.py b/ami/main/migrations/0101_grant_run_post_processing_to_ml_data_manager.py
new file mode 100644
index 000000000..5ca05f0a7
--- /dev/null
+++ b/ami/main/migrations/0101_grant_run_post_processing_to_ml_data_manager.py
@@ -0,0 +1,83 @@
+"""
+Grant ``run_post_processing_job`` to ``MLDataManager`` and ``ProjectManager`` role groups on
+existing projects, so the roles that run ML jobs can also start tracking runs through the jobs API.
+
+The grant is a guardian object-level permission per project, which is what
+``user.has_perm(codename, project)`` reads; see 0095 for the same pattern. The
+``post_migrate`` role sync also applies it, and this migration keeps the grant explicit.
+"""
+
+from django.db import migrations
+from django.db.models import Q
+
+CODENAME = "run_post_processing_job"
+# ProjectManager inherits MLDataManager's permissions, so both groups hold the grant.
+ROLE_SUFFIXES = ("_MLDataManager", "_ProjectManager")
+
+
+def _role_groups() -> Q:
+    return Q(name__endswith=ROLE_SUFFIXES[0]) | Q(name__endswith=ROLE_SUFFIXES[1])
+
+
+def _permission(apps):
+    Permission = apps.get_model("auth", "Permission")
+    ContentType = apps.get_model("contenttypes", "ContentType")
+    try:
+        project_ct = ContentType.objects.get(app_label="main", model="project")
+    except ContentType.DoesNotExist:
+        return None, None
+    try:
+        return Permission.objects.get(codename=CODENAME, content_type=project_ct), project_ct
+    except Permission.DoesNotExist:
+        return None, None
+
+
+def _project_pk_from_group(group):
+    # Group names are "{project_pk}_{project_name}_{RoleName}"; the pk is the leading segment.
+    try:
+        return int(group.name.split("_", 1)[0])
+    except (ValueError, IndexError):
+        return None
+
+
+def grant(apps, schema_editor):
+    Group = apps.get_model("auth", "Group")
+    GroupObjectPermission = apps.get_model("guardian", "GroupObjectPermission")
+
+    perm, project_ct = _permission(apps)
+    if perm is None:
+        return
+    for group in Group.objects.filter(_role_groups()):
+        project_pk = _project_pk_from_group(group)
+        if project_pk is None:
+            continue
+        group.permissions.add(perm)
+        GroupObjectPermission.objects.get_or_create(
+            permission=perm, content_type=project_ct, object_pk=str(project_pk), group=group
+        )
+
+
+def revoke(apps, schema_editor):
+    Group = apps.get_model("auth", "Group")
+    GroupObjectPermission = apps.get_model("guardian", "GroupObjectPermission")
+
+    perm, project_ct = _permission(apps)
+    if perm is None:
+        return
+    for group in Group.objects.filter(_role_groups()):
+        project_pk = _project_pk_from_group(group)
+        if project_pk is None:
+            continue
+        group.permissions.remove(perm)
+        GroupObjectPermission.objects.filter(
+            permission=perm, content_type=project_ct, object_pk=str(project_pk), group=group
+        ).delete()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("main", "0100_occurrence_track_stats"),
+        ("guardian", "0002_generic_permissions_index"),
+    ]
+
+    operations = [migrations.RunPython(grant, revoke)]
diff --git a/ami/main/models.py b/ami/main/models.py
index 9943c111a..9bddb6353 100644
--- a/ami/main/models.py
+++ b/ami/main/models.py
@@ -11,6 +11,7 @@
 from io import BytesIO
 from typing import Final, final  # noqa: F401
 
+import pgvector.django
 import PIL.Image
 import pydantic
 from django.apps import apps
@@ -279,6 +280,7 @@ class ProjectFeatureFlags(pydantic.BaseModel):
     # Feature flag for jobs to reprocess all images in the project, even if already processed
     reprocess_all_images: bool = False
     async_pipeline_workers: bool = True  # Whether to use async pipeline workers that pull tasks from a queue
+    tracking: bool = False  # Whether members can run occurrence tracking and edit tracks
 
 
 def get_default_feature_flags() -> ProjectFeatureFlags:
@@ -427,6 +429,20 @@ def check_custom_permission(self, user, action: str) -> bool:
         # Fall back to default permission checking for other actions
         return super().check_custom_permission(user, action)
 
+    def get_custom_user_permissions(self, user) -> list[str]:
+        # Reads the permissions once for both the project actions and the tracking check.
+        perms = set(get_perms(user, self))
+        custom_perms = {
+            perm.split("_", 1)[0]
+            for perm in perms
+            if perm.endswith("_project") and perm.split("_", 1)[0] not in ("view", "create", "update", "delete")
+        }
+        # Mirrors what creating and then running a tracking job checks, so the UI can offer it.
+        tracking_job_perms = {Project.Permissions.CREATE_JOB, Project.Permissions.RUN_POST_PROCESSING_JOB}
+        if self.feature_flags.tracking and tracking_job_perms <= perms:
+            custom_perms.add(Project.Permissions.RUN_TRACKING)
+        return list(custom_perms)
+
     class Permissions:
         """CRUD Permission names follow the convention: `create_<model>`, `update_<model>`,
         `delete_<model>`, `view_<model>`"""
@@ -452,6 +468,8 @@ class Permissions:
         RUN_REGROUP_EVENTS_JOB = "run_regroup_events_job"
         RUN_DATA_EXPORT_JOB = "run_data_export_job"
         RUN_POST_PROCESSING_JOB = "run_post_processing_job"
+        # Not a stored permission: reported to the UI when the tracking job permissions and flag all hold.
+        RUN_TRACKING = "run_tracking"
         DELETE_JOB = "delete_job"
 
         # Deployment permissions
@@ -1441,6 +1459,29 @@ def update_calculated_fields_for_events(
     return to_update
 
 
+def update_calculated_fields_for_sessions_and_stations(
+    event_ids: typing.Iterable[int | None], stations_async: bool = True
+) -> None:
+    """Refresh the cached counts of these sessions and of the stations they belong to.
+
+    Call once after occurrences are created, merged or split, which neither the
+    occurrence nor the detection saves do. The project's counts are live and need nothing.
+    The station refresh scans the whole station, so by default it runs in a background
+    task after the transaction commits, keeping it and the station row lock out of the request.
+    """
+    from ami.main.tasks import refresh_deployment_cached_counts
+
+    pks = sorted({pk for pk in event_ids if pk is not None})
+    if not pks:
+        return
+    update_calculated_fields_for_events(pks=pks)
+    deployment_ids = list(Deployment.objects.filter(events__pk__in=pks).values_list("pk", flat=True).distinct())
+    if stations_async:
+        transaction.on_commit(lambda: refresh_deployment_cached_counts.delay(deployment_ids))
+    else:
+        refresh_deployment_cached_counts(deployment_ids)
+
+
 def audit_event_lengths(deployment: Deployment):
     logger.info("Checking for unusual event durations")
 
@@ -1648,6 +1689,8 @@ def _group_images_into_events_locked(
         f"Done grouping {len(image_timestamps)} captures into {len(events)} events " f"for deployment {deployment}"
     )
 
+    tracks_split_count = _split_tracks_at_session_boundaries(deployment, job)
+
     # Realign Occurrence.event_id with each occurrence's detections' current
     # source_image.event_id. Occurrences are bound to an event once at creation
     # time (Detection.associate_new_occurrence and Pipeline.save_results both
@@ -1728,6 +1771,7 @@ def _group_images_into_events_locked(
             "Events created": events_created_count,
             "Events touched": len(touched_event_pks),
             "Empty events deleted": events_deleted_empty,
+            "Occurrences split at a session boundary": tracks_split_count,
             "Duplicate timestamps": duplicate_timestamp_count,
             "Ungrouped captures": ungrouped_captures_count,
             "Captures missing timestamp": no_timestamp_captures_count,
@@ -1740,6 +1784,35 @@ def _group_images_into_events_locked(
     return events
 
 
+def _split_tracks_at_session_boundaries(deployment: Deployment, job: "Job | None") -> int:
+    """Split every occurrence in the deployment whose detections now span several sessions.
+
+    Users expect one occurrence per session, so a regroup that draws a session boundary
+    through a track leaves one piece per session. Returns how many occurrences were split.
+    """
+    from ami.main.models_future.tracks import split_at_session_boundaries
+
+    spanning_ids = list(
+        Detection.objects.valid()
+        .filter(occurrence__deployment=deployment)
+        .values("occurrence_id")
+        .annotate(sessions=models.Count("source_image__event", distinct=True))
+        .filter(sessions__gt=1)
+        .values_list("occurrence_id", flat=True)
+    )
+    split_count = 0
+    for occurrence in Occurrence.objects.filter(pk__in=spanning_ids).order_by("pk"):
+        pieces = split_at_session_boundaries(occurrence)
+        if not pieces:
+            continue
+        split_count += 1
+        (job.logger if job else logger).info(
+            f"Split occurrence {occurrence.pk} at a session boundary; "
+            f"new occurrence(s) {[piece.pk for piece in pieces]} hold the later sessions."
+        )
+    return split_count
+
+
 def deployment_events_need_update(deployment: Deployment) -> bool:
     """
     Returns True if there are any SourceImages in the deployment
@@ -2127,6 +2200,30 @@ def with_was_processed(self):
         processed_exists = models.Exists(Detection.objects.filter(source_image_id=models.OuterRef("pk")))
         return self.annotate(was_processed=processed_exists)
 
+    def with_detections_with_features(self):
+        """Annotate ``detections_with_features`` and the ``detections_valid`` it is out of:
+        valid detections on the capture, and how many of them have a classification that
+        stored a feature embedding. Counted in SQL so the vectors themselves are never
+        loaded. Both come from the same population, so a caller can show one as a share of
+        the other; the cached ``detections_count`` is a different, default-filtered count.
+        """
+
+        def count_valid(**extra):
+            return models.Subquery(
+                Detection.objects.valid()
+                .filter(source_image_id=models.OuterRef("pk"), **extra)
+                .order_by()
+                .values("source_image_id")
+                .annotate(count=models.Count("id", distinct=True))
+                .values("count"),
+                output_field=models.IntegerField(),
+            )
+
+        return self.annotate(
+            detections_valid=Coalesce(count_valid(), 0),
+            detections_with_features=Coalesce(count_valid(classifications__features_2048__isnull=False), 0),
+        )
+
     def with_thumbnails(self):
         """Prefetch ``thumbnails`` so :meth:`SourceImage.thumbnail_urls` decides
         warm/cold in memory instead of firing a SELECT per row.
@@ -2346,6 +2443,24 @@ def event_prev_capture_id(self) -> int | None:
         """
         return None
 
+    def event_next_capture_with_detections_id(self) -> int | None:
+        """
+        Return the nearest later capture in the event that holds a real detection.
+
+        Populated by the query in the ViewSet (see add_adjacent_captures); ties on
+        timestamp are broken by id.
+        """
+        return None
+
+    def event_prev_capture_with_detections_id(self) -> int | None:
+        """
+        Return the nearest earlier capture in the event that holds a real detection.
+
+        Populated by the query in the ViewSet (see add_adjacent_captures); ties on
+        timestamp are broken by id.
+        """
+        return None
+
     def event_current_capture_index(self) -> int | None:
         """
         Return the index of the current capture in the event.
@@ -2943,6 +3058,17 @@ class ClassificationResult(BaseModel):
 
 
 class ClassificationQuerySet(BaseQuerySet):
+    def with_has_features(self):
+        """Annotate ``has_features`` and defer the embedding itself.
+
+        Read paths only need to know whether a feature vector was stored; deferring the
+        2048-float column keeps it out of the row's SELECT. A select_related self-join
+        (``applied_to``) needs its own ``defer("applied_to__features_2048")``.
+        """
+        return self.defer("features_2048").annotate(
+            has_features=models.ExpressionWrapper(Q(features_2048__isnull=False), output_field=models.BooleanField())
+        )
+
     def find_duplicates(self, project_id: int | None = None) -> models.QuerySet:
         # Find the oldest classification for each unique combination
         if project_id:
@@ -2987,6 +3113,11 @@ class Classification(BaseModel):
         null=True,
         help_text="The probabilities the model, calibrated by the model maker, likely the softmax output",
     )
+    features_2048 = pgvector.django.VectorField(
+        dimensions=2048,
+        null=True,
+        help_text="Feature embedding from the model backbone",
+    )
     category_map = models.ForeignKey("ml.AlgorithmCategoryMap", on_delete=models.PROTECT, null=True)
 
     algorithm = models.ForeignKey(
@@ -3197,6 +3328,15 @@ class Detection(BaseModel):
 
     similarity_vector = models.JSONField(null=True, blank=True)
 
+    next_detection = models.OneToOneField(
+        "self",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="previous_detection",
+        help_text="The detection that follows this one in the tracking sequence.",
+    )
+
     # For type hints
     classifications: models.QuerySet["Classification"]
     source_image_id: int
@@ -3328,7 +3468,7 @@ def update_calculated_fields(self, save=True):
             self.timestamp = self.source_image.timestamp
             needs_update = True
         if save and needs_update:
-            self.save(update_calculated_fields=False)
+            self.save(update_calculated_fields=False, update_fields=["timestamp"])
 
     def save(self, update_calculated_fields=True, *args, **kwargs):
         super().save(*args, **kwargs)
@@ -3354,13 +3494,44 @@ def valid(self):
             them)
           - Occurrences with determination__isnull=True (no taxonomic identification,
             same field bug shape)
+
+        Opening or repairing one occurrence needs the wider set that keeps
+        undetermined ones: see with_real_detections().
+        """
+        return self.with_real_detections().exclude(determination__isnull=True)
+
+    def with_real_detections(self):
+        """
+        Occurrences backed by at least one real bounding box, determined or not.
+
+        This is what the occurrence detail and the track-edit endpoints work over. A
+        reviewer opening or repairing a track has to reach occurrences the list hides,
+        and on a project where only a detector ran every occurrence is undetermined.
+        Null-marker sentinels stay excluded exactly as in valid(), since they carry no
+        box to put in a track.
         """
         has_valid_detection = Exists(Detection.objects.valid().filter(occurrence_id=OuterRef("pk")))
-        return self.filter(has_valid_detection).exclude(determination__isnull=True)
+        return self.filter(has_valid_detection)
 
     def with_detections_count(self):
         return self.annotate(detections_count=models.Count("detections", distinct=True))
 
+    def with_frames_with_vectors(self):
+        """Annotate ``frames_with_vectors``: detections in the occurrence with at least one
+        classification that stored a feature embedding. Counted in SQL so the vectors
+        themselves are never loaded.
+        """
+        subquery = (
+            Detection.objects.filter(occurrence_id=OuterRef("pk"), classifications__features_2048__isnull=False)
+            .order_by()
+            .values("occurrence_id")
+            .annotate(count=models.Count("id", distinct=True))
+            .values("count")
+        )
+        return self.annotate(
+            frames_with_vectors=Coalesce(models.Subquery(subquery, output_field=models.IntegerField()), 0)
+        )
+
     def _processed_by_algorithm_q(self, algorithm_ids) -> Exists:
         """Subquery matching occurrences with any result from the given algorithms —
         a detection made by one (detectors) or a classification from one (classifiers
@@ -3416,10 +3587,15 @@ def with_list_prefetches(self):
         return self.prefetch_related(prefetch_detections_for_list())
 
     def with_detail_prefetches(self):
-        """Add prefetches the detail serializer needs (detections + source_image + classifications)."""
+        """Add what the detail serializer needs: detections + source_image + classifications
+        prefetched, and the ``frames_with_vectors`` count the grouping summary reports."""
         from ami.main.models_future.occurrence import prefetch_detections_for_detail
 
-        return self.prefetch_related(prefetch_detections_for_detail())
+        return (
+            self.select_related("grouping_verified_by")
+            .prefetch_related(prefetch_detections_for_detail())
+            .with_frames_with_vectors()
+        )
 
     def with_best_detection(self):
         """
@@ -3566,7 +3742,12 @@ def filter_by_project_default_taxa(self, project: Project | None = None, request
 
         return qs
 
-    def apply_default_filters(self, project: Project | None = None, request: Request | None = None):
+    def apply_default_filters(
+        self,
+        project: Project | None = None,
+        request: Request | None = None,
+        include_undetermined: bool = False,
+    ):
         """
         Apply all default filters to occurrences based on project settings.
 
@@ -3576,6 +3757,10 @@ def apply_default_filters(self, project: Project | None = None, request: Request
         Args:
             project: The project whose default filters should be applied
             request: The request object (optional, used to check for apply_defaults=false)
+            include_undetermined: Keep occurrences with no determination, which every
+                default filter would otherwise drop: an undetermined occurrence has
+                neither a score nor a taxon to test against, and on a project where
+                only a detector ran that is all of them.
 
         Returns:
             Filtered queryset with both score and taxa filters applied
@@ -3596,6 +3781,8 @@ def apply_default_filters(self, project: Project | None = None, request: Request
 
         # Use build_occurrence_default_filters_q to get the combined filter and apply it
         filter_q = build_occurrence_default_filters_q(project, request, occurrence_accessor="")
+        if include_undetermined:
+            filter_q |= models.Q(determination__isnull=True)
         return self.filter(filter_q)
 
 
@@ -3625,11 +3812,53 @@ class Occurrence(BaseModel):
     deployment = models.ForeignKey(Deployment, on_delete=models.SET_NULL, null=True, related_name="occurrences")
     project = models.ForeignKey("Project", on_delete=models.SET_NULL, null=True, related_name="occurrences")
 
+    # Whether a person has confirmed that this occurrence's set of detections is right —
+    # that they are all the same individual and none are missing. Separate from taxon
+    # verification, which is what an Identification records. Confirmed occurrences are the
+    # ground truth the tracking methods are evaluated against, so anything that changes the
+    # detection set must clear this. See #1272.
+    grouping_verified_at = models.DateTimeField(null=True, blank=True)
+    grouping_verified_by = models.ForeignKey(
+        "users.User",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="verified_occurrence_groupings",
+    )
+
+    # Track statistics stored so the occurrence list can sort by them. Written by
+    # ``models_future.track_stats.refresh_track_stats`` whenever tracking or a track edit
+    # changes which detections an occurrence holds; null until then, or when it has none.
+    track_motion = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Path length between frames as a fraction of the frame diagonal. See models_future/track_stats.py.",
+    )
+    track_size_ratio = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Largest box area over the smallest. See models_future/track_stats.py.",
+    )
+    track_distinct_taxa = models.IntegerField(
+        null=True,
+        blank=True,
+        help_text="Distinct taxa among terminal classifications. See models_future/track_stats.py.",
+    )
+    track_id_agreement = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Share of terminal classifications naming the determination. See models_future/track_stats.py.",
+    )
+
     detections: models.QuerySet[Detection]
     identifications: models.QuerySet[Identification]
 
     objects = OccurrenceManager()
 
+    @property
+    def grouping_verified(self) -> bool:
+        return self.grouping_verified_at is not None
+
     def __str__(self) -> str:
         name = f"Occurrence #{self.pk}"
         if self.deployment:
@@ -3744,6 +3973,7 @@ def predictions(self):
         classifications = (
             Classification.objects.filter(detection__occurrence=self)
             .select_related("taxon", "algorithm")
+            .with_has_features()
             .filter(
                 score__in=models.Subquery(
                     Classification.objects.filter(detection__occurrence=self)
@@ -3787,6 +4017,32 @@ def save(self, update_determination=True, *args, **kwargs):
             else:
                 self.save(update_determination=False)
 
+    def check_custom_permission(self, user, action: str) -> bool:
+        # Editing a track moves detections between occurrences and can leave an
+        # occurrence's determination changed, so it is gated on the permission that
+        # already governs restructuring occurrence records rather than on
+        # identification rights.
+        # Listing merge candidates and scoring a capture's boxes are gated the same way,
+        # so those pickers only open for someone who could complete the edit.
+        if action in (
+            "split_track",
+            "remove_detection",
+            "merge",
+            "merge_candidates",
+            "capture_matches",
+            "add_detections",
+        ):
+            return user.has_perm(Project.Permissions.DELETE_OCCURRENCES, self.get_project())
+        # Confirming a grouping is an expert judgement rather than a restructuring, so
+        # identifying rights are enough — but the roles that restructure occurrences do
+        # not inherit those, and they need to confirm their own corrections.
+        if action in ("verify_grouping", "unverify_grouping"):
+            project = self.get_project()
+            return user.has_perm(Project.Permissions.CREATE_IDENTIFICATION, project) or user.has_perm(
+                Project.Permissions.DELETE_OCCURRENCES, project
+            )
+        return super().check_custom_permission(user, action)
+
     class Meta:
         ordering = ["-determination_score"]
         indexes = [
@@ -3856,9 +4112,17 @@ def update_occurrence_determination(
         new_score = top_identification.score
     elif not top_identification:
         top_prediction = occurrence.best_prediction
-        if top_prediction and top_prediction.taxon and top_prediction.taxon != current_determination:
-            new_determination = top_prediction.taxon
-            new_score = top_prediction.score
+        if top_prediction and top_prediction.taxon:
+            if top_prediction.taxon != current_determination:
+                new_determination = top_prediction.taxon
+                new_score = top_prediction.score
+            elif top_prediction.score != occurrence.determination_score:
+                # Taxon unchanged but a higher-scoring classification has appeared
+                # for the same taxon (e.g. tracking merged a new detection into the
+                # chain whose top species classification scored higher than the
+                # keeper's). Refresh the score so determination_score reflects the
+                # best evidence available across the occurrence's detections.
+                new_score = top_prediction.score
 
     if new_determination and new_determination != current_determination:
         logger.debug(f"Changing det. of {occurrence} from {current_determination} to {new_determination}")
diff --git a/ami/main/models_future/merge_candidates.py b/ami/main/models_future/merge_candidates.py
new file mode 100644
index 000000000..7cef580ac
--- /dev/null
+++ b/ami/main/models_future/merge_candidates.py
@@ -0,0 +1,530 @@
+"""Other occurrences one occurrence could be merged with, best fit first.
+
+Tracking leaves one animal as two occurrences rather than risk merging two animals,
+so the repair is a merge a person chooses. This ranks the choices the way tracking
+would have: by the matching cost between the two frames, one from each, that are
+nearest in time.
+
+Candidates are occurrences of the same session with a frame among the searched
+captures. By default those are the captures adjacent to the occurrence: a number of
+captures before its first frame and after its last one (``captures``), plus the
+captures inside its own span. Passing ``minutes`` searches from that many minutes
+before the first frame to that many minutes after the last instead.
+
+One animal cannot appear twice in one capture, so an occurrence with a frame on one
+of the occurrence's captures is another animal and is never offered. In a dense
+session those outnumber the true neighbours many times over.
+
+Each candidate is described by:
+
+- ``relation``: ``before`` when the candidate ends before the occurrence starts,
+  ``after`` when it starts after the occurrence ends, and ``gap`` otherwise: it lies
+  within the occurrence's span on captures the occurrence has no frame on, where
+  tracking lost the animal for a few captures.
+- ``time_offset_seconds``: the gap between the two spans, negative for ``before``,
+  positive for ``after`` and zero for ``gap``.
+- ``distance``: centre-to-centre distance of the nearest pair of boxes as a fraction
+  of the frame diagonal.
+- ``similarity``: cosine similarity of the pair's feature vectors, from the same
+  algorithm that produced the occurrence's own vector. Null when either has none.
+- ``cost``: the tracking method's matching cost for the pair. Geometry only when
+  similarity is null, which lowers the total, so a candidate without a vector can
+  outrank one with a poor vector match. Null when either box is malformed.
+- ``iou``, ``size_ratio`` and ``likelihood``: the remaining terms of that cost and
+  one minus its mean term, the same numbers the capture preview reports.
+- ``would_link``: whether the pair passes the tracker's pairing rule, a cost under
+  its threshold with a vector on both frames when it requires one.
+- ``capture_id`` and ``image_timestamp``: the candidate's frame in the scored pair,
+  the one its ``image`` is a crop of.
+- ``edge_image`` and ``edge_timestamp``: the track frame in the scored pair: its first
+  frame for a ``before`` candidate, its last for an ``after`` one, the nearest one in
+  time for a ``gap`` candidate. The two crops can then be shown side by side.
+
+Candidates of every relation are sorted together by cost and capped once.
+
+Vectors are loaded only for the frames in the scored pairs: one per candidate and the
+occurrence's frames those are paired with.
+
+Passing ``detection_id`` ranks destinations for that one frame of the occurrence
+instead, for moving it to another occurrence: the frame stands in for the whole track,
+so the search, the exclusions and the scores are all taken from it alone.
+
+``match_capture_detections`` previews what tracking would link on one capture, with the
+tracker's own matcher, for a person extending the track capture by capture.
+"""
+
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any
+
+from django.db.models import Q, QuerySet
+
+from ami.main.models_future.track_stats import bbox_corners, frame_diagonal
+
+if TYPE_CHECKING:
+    from ami.main.models import Occurrence, SourceImage
+    from ami.ml.post_processing.tracking_task import TrackingConfig
+
+DEFAULT_WINDOW_MINUTES = 5
+MAX_WINDOW_MINUTES = 30
+DEFAULT_ADJACENT_CAPTURES = 1
+MAX_ADJACENT_CAPTURES = 10
+MAX_CANDIDATES = 50
+
+RELATION_BEFORE = "before"
+RELATION_AFTER = "after"
+RELATION_GAP = "gap"
+RELATIONS = (RELATION_BEFORE, RELATION_AFTER, RELATION_GAP)
+# A capture that already holds one of the track's frames, scored against another frame.
+RELATION_SAME = "same"
+CAPTURE_MATCH_RELATIONS = (*RELATIONS, RELATION_SAME)
+
+_ROUND_TO = 4
+
+# One frame as a plain row, so nothing here can trigger a deferred-field query.
+_FRAME_FIELDS = (
+    "pk",
+    "occurrence_id",
+    "source_image_id",
+    "timestamp",
+    "bbox",
+    "path",
+    "source_image__width",
+    "source_image__height",
+)
+
+
+class DetectionNotInOccurrence(ValueError):
+    """The frame asked to be ranked for is not a frame of the occurrence."""
+
+
+def _timed_frames(queryset) -> list[dict[str, Any]]:
+    return [row for row in queryset.order_by("timestamp", "pk").values(*_FRAME_FIELDS) if row["timestamp"] is not None]
+
+
+def _adjacent_capture_ids(
+    event_id: int, first: datetime.datetime, last: datetime.datetime, captures: int
+) -> list[int]:
+    """Ids of the ``captures`` captures of the session just before ``first`` and just after ``last``.
+
+    The ids are materialised so the frame query filters on literal values, which the
+    planner can serve from the index instead of scanning the detections table.
+    """
+    from ami.main.models import SourceImage
+
+    session = SourceImage.objects.filter(event_id=event_id)
+    before = session.filter(timestamp__lt=first).order_by("-timestamp", "-pk").values_list("pk", flat=True)
+    after = session.filter(timestamp__gt=last).order_by("timestamp", "pk").values_list("pk", flat=True)
+    return list(before[:captures]) + list(after[:captures])
+
+
+def _nearest_pair(track_frames: list[dict], frames: list[dict]) -> tuple[dict, dict]:
+    """The track frame and candidate frame closest to each other in time."""
+    return min(
+        ((track_frame, frame) for track_frame in track_frames for frame in frames),
+        key=lambda pair: (abs(pair[1]["timestamp"] - pair[0]["timestamp"]), pair[0]["pk"], pair[1]["pk"]),
+    )
+
+
+def _relation(
+    target_first: datetime.datetime,
+    target_last: datetime.datetime,
+    candidate_first: datetime.datetime,
+    candidate_last: datetime.datetime,
+) -> tuple[str, float]:
+    if candidate_last < target_first:
+        return RELATION_BEFORE, (candidate_last - target_first).total_seconds()
+    if candidate_first > target_last:
+        return RELATION_AFTER, (candidate_first - target_last).total_seconds()
+    return RELATION_GAP, 0.0
+
+
+def _pair_diagonal(track_frame: dict, frame: dict, corners_a, corners_b) -> float:
+    """The tracking method's integer diagonal when the captures carry dimensions, else
+    the same fallback the track stats use."""
+    from ami.ml.post_processing.tracking_task import image_diagonal
+
+    width = max(track_frame["source_image__width"] or 0, frame["source_image__width"] or 0)
+    height = max(track_frame["source_image__height"] or 0, frame["source_image__height"] or 0)
+    if width and height:
+        return float(image_diagonal(width, height))
+    return frame_diagonal(None, None, max(corners_a[2], corners_b[2]), max(corners_a[3], corners_b[3]))
+
+
+def _latest_vectors(classifications) -> dict[tuple[int, int], Any]:
+    """Most recent feature vector per (detection, algorithm) among the rows given."""
+    vectors: dict[tuple[int, int], Any] = {}
+    rows = classifications.order_by("-timestamp", "-pk").values_list("detection_id", "algorithm_id", "features_2048")
+    for detection_id, algorithm_id, vector in rows:
+        vectors.setdefault((detection_id, algorithm_id), vector)
+    return vectors
+
+
+def _score_pair(track_frame: dict, frame: dict, track_vector, frame_vector) -> dict[str, float | None]:
+    """The cost terms for one pair of frames, all None for a box that cannot be read."""
+    corners_a = bbox_corners(track_frame["bbox"])
+    corners_b = bbox_corners(frame["bbox"])
+    if corners_a is None or corners_b is None:
+        return dict.fromkeys(_PAIR_SCORE_FIELDS)
+    diagonal = _pair_diagonal(track_frame, frame, corners_a, corners_b)
+    return _pair_scores(corners_a, corners_b, track_vector, frame_vector, diagonal)
+
+
+def _would_link(scores: dict[str, float | None], config: TrackingConfig) -> bool:
+    """Whether the pair passes the tracker's pairing rule: a cost under its threshold, and a
+    vector on both frames when it requires them. A preview of the rule, not of a run: the
+    matcher only pairs adjacent captures and claims each box once."""
+    if scores["cost"] is None or (config.require_features and scores["similarity"] is None):
+        return False
+    return scores["cost"] < config.cost_threshold
+
+
+def _rank_key(row: dict[str, Any]) -> tuple:
+    """Lowest cost first, unscored rows last, nearest in time and then oldest as tie-breaks."""
+    return (row["cost"] is None, row["cost"] or 0.0, abs(row["time_offset_seconds"]), row["id"])
+
+
+def rank_merge_candidates(
+    occurrence: Occurrence,
+    occurrences: QuerySet[Occurrence],
+    minutes: int | None = None,
+    captures: int = DEFAULT_ADJACENT_CAPTURES,
+    limit: int = MAX_CANDIDATES,
+    detection_id: int | None = None,
+) -> list[dict[str, Any]]:
+    """Candidates for merging with ``occurrence``, lowest cost first, at most ``limit``.
+
+    The captures searched are the ``captures`` captures before the occurrence's first
+    frame and after its last one, plus those inside its span, unless ``minutes`` is
+    given, in which case the search runs from that many minutes before the first
+    frame to that many minutes after the last.
+
+    Candidates with a frame on one of the occurrence's captures are dropped using the
+    frames already loaded. That is exact because those captures all lie inside the
+    occurrence's span, which both searches cover in full.
+
+    ``occurrences`` decides which occurrences may be offered at all: pass the API's
+    queryset so visibility and the project's default filters apply, and so the list
+    matches what the merge action accepts. It must carry ``with_timestamps()`` and
+    ``with_detections_count()`` and select ``determination``. Prefetches on it are
+    wasted, since only the annotated fields are read.
+
+    The query count does not depend on how many candidates there are: the
+    occurrence's frames, the adjacent capture ids (two queries, skipped in minutes
+    mode), the searched frames, the candidate occurrences, and one vector query for
+    each side of the pairs.
+
+    With ``detection_id`` the ranking is for moving that one frame, so it is scored in
+    place of the track's frames. Raises ``DetectionNotInOccurrence`` when it is not one
+    of the occurrence's frames.
+    """
+    from ami.main.models import Classification, Detection, get_media_url
+
+    config = tracking_config_for(occurrence)
+    track = Detection.objects.valid().filter(occurrence_id=occurrence.pk)
+    if detection_id is None:
+        target_frames = _timed_frames(track)
+    else:
+        # Read without the timestamp filter, so an untimed frame of the occurrence is not
+        # mistaken for another occurrence's frame.
+        rows = list(track.filter(pk=detection_id).values(*_FRAME_FIELDS))
+        if not rows:
+            raise DetectionNotInOccurrence(detection_id)
+        target_frames = [row for row in rows if row["timestamp"] is not None]
+    if not target_frames:
+        return []
+    first, last = target_frames[0], target_frames[-1]
+    target_captures = {frame["source_image_id"] for frame in target_frames}
+
+    if minutes is not None:
+        delta = datetime.timedelta(minutes=minutes)
+        searched = Q(timestamp__range=(first["timestamp"] - delta, last["timestamp"] + delta))
+    else:
+        adjacent = _adjacent_capture_ids(occurrence.event_id, first["timestamp"], last["timestamp"], captures)
+        searched = Q(source_image_id__in=adjacent) | Q(timestamp__range=(first["timestamp"], last["timestamp"]))
+    nearby = _timed_frames(
+        Detection.objects.valid()
+        .filter(searched, occurrence__event_id=occurrence.event_id)
+        .exclude(occurrence_id=occurrence.pk)
+        .exclude(occurrence_id__isnull=True)
+    )
+    other_animals = {frame["occurrence_id"] for frame in nearby if frame["source_image_id"] in target_captures}
+    frames_by_occurrence: dict[int, list[dict]] = {}
+    for frame in nearby:
+        if frame["occurrence_id"] not in other_animals:
+            frames_by_occurrence.setdefault(frame["occurrence_id"], []).append(frame)
+    if not frames_by_occurrence:
+        return []
+
+    scored = [
+        (
+            candidate,
+            *_relation(
+                first["timestamp"],
+                last["timestamp"],
+                candidate.first_appearance_timestamp,
+                candidate.last_appearance_timestamp,
+            ),
+        )
+        for candidate in occurrences.filter(pk__in=list(frames_by_occurrence))
+    ]
+    if not scored:
+        return []
+
+    # A gap candidate lies inside the track's span, so any track frame can be nearest it.
+    track_side = {RELATION_BEFORE: [first], RELATION_AFTER: [last], RELATION_GAP: target_frames}
+    pairs = {
+        candidate.pk: _nearest_pair(track_side[relation], frames_by_occurrence[candidate.pk])
+        for candidate, relation, _ in scored
+    }
+
+    track_vectors = _latest_vectors(
+        Classification.objects.filter(
+            detection_id__in={track_frame["pk"] for track_frame, _ in pairs.values()},
+            algorithm_id__isnull=False,
+            features_2048__isnull=False,
+        )
+    )
+    frame_vectors: dict[tuple[int, int], Any] = {}
+    if track_vectors:
+        frame_vectors = _latest_vectors(
+            Classification.objects.filter(
+                detection_id__in=[frame["pk"] for _, frame in pairs.values()],
+                algorithm_id__in={algorithm_id for _, algorithm_id in track_vectors},
+                features_2048__isnull=False,
+            )
+        )
+    vector_by_track_frame = {
+        detection_id: (algorithm_id, vector) for (detection_id, algorithm_id), vector in track_vectors.items()
+    }
+
+    rows: list[dict[str, Any]] = []
+    for candidate, relation, offset in scored:
+        track_frame, frame = pairs[candidate.pk]
+        algorithm_id, track_vector = vector_by_track_frame.get(track_frame["pk"], (None, None))
+        frame_vector = frame_vectors.get((frame["pk"], algorithm_id)) if algorithm_id is not None else None
+        scores = _score_pair(track_frame, frame, track_vector, frame_vector)
+        crop = frame["path"] or next((f["path"] for f in frames_by_occurrence[candidate.pk] if f["path"]), None)
+        rows.append(
+            {
+                "id": candidate.pk,
+                "determination": (
+                    {"id": candidate.determination_id, "name": candidate.determination.name}
+                    if candidate.determination_id
+                    else None
+                ),
+                "detections_count": candidate.detections_count,
+                "first_appearance_timestamp": candidate.first_appearance_timestamp,
+                "last_appearance_timestamp": candidate.last_appearance_timestamp,
+                "relation": relation,
+                "time_offset_seconds": offset,
+                **scores,
+                "would_link": _would_link(scores, config),
+                "image": get_media_url(crop) if crop else None,
+                "capture_id": frame["source_image_id"],
+                "image_timestamp": frame["timestamp"],
+                "edge_image": get_media_url(track_frame["path"]) if track_frame["path"] else None,
+                "edge_timestamp": track_frame["timestamp"],
+            }
+        )
+
+    rows.sort(key=_rank_key)
+    return rows[:limit]
+
+
+_PAIR_SCORE_FIELDS = ("likelihood", "cost", "distance", "iou", "size_ratio", "similarity")
+_MATCH_SCORE_FIELDS = _PAIR_SCORE_FIELDS + ("time_offset_seconds",)
+SKIPPED_NO_VECTOR = "no_vector"
+SKIPPED_REASONS = (SKIPPED_NO_VECTOR,)
+
+
+def tracking_config_for(occurrence: Occurrence) -> TrackingConfig:
+    """The settings tracking runs with on the occurrence's session: the threshold and the
+    feature requirement the previews here judge pairs by."""
+    from ami.ml.post_processing.tracking_task import TrackingConfig
+
+    return TrackingConfig(event_ids=[occurrence.event_id])
+
+
+def _likelihood(cost: float, similarity: float | None) -> float:
+    # One minus the mean cost term. Every term lies in [0, 1], so a value reads the same on any
+    # capture, and the tracker's 0.2 cut-off sits near 0.95. It stays continuous so near misses
+    # still read as likely; ``would_link`` carries the tracker's own decision.
+    terms = 3 if similarity is None else 4
+    return round(min(max(1 - cost / terms, 0.0), 1.0), _ROUND_TO)
+
+
+def _pair_scores(bbox_a, bbox_b, vector_a, vector_b, diag: float) -> dict[str, float | None]:
+    """The tracking cost between two boxes, each of its terms, and the likelihood."""
+    from ami.ml.post_processing.tracking_task import box_ratio, cosine_similarity, distance_ratio, iou, total_cost
+
+    cost = total_cost(vector_a, vector_b, bbox_a, bbox_b, diag)
+    similarity = None
+    if vector_a is not None and vector_b is not None:
+        similarity = round(cosine_similarity(vector_a, vector_b), _ROUND_TO)
+    return {
+        "likelihood": _likelihood(cost, similarity),
+        "cost": round(cost, _ROUND_TO),
+        "distance": round(distance_ratio(bbox_a, bbox_b, diag), _ROUND_TO),
+        "iou": round(iou(bbox_a, bbox_b), _ROUND_TO),
+        "size_ratio": round(box_ratio(bbox_a, bbox_b), _ROUND_TO),
+        "similarity": similarity,
+    }
+
+
+def _reference_frame(occurrence_id: int, capture: SourceImage) -> tuple[dict | None, str | None]:
+    """The track frame nearest in time to ``capture`` on another capture, and which side of
+    the track the capture lies on, read from the nearest frame on each side of it."""
+    from ami.main.models import Detection
+
+    track = (
+        Detection.objects.valid()
+        .filter(occurrence_id=occurrence_id, timestamp__isnull=False)
+        .exclude(source_image_id=capture.pk)
+    )
+    earlier = track.filter(timestamp__lte=capture.timestamp).order_by("-timestamp", "-pk").values(*_FRAME_FIELDS)
+    later = track.filter(timestamp__gte=capture.timestamp).order_by("timestamp", "pk").values(*_FRAME_FIELDS)
+    frames = sorted(earlier[:1].union(later[:1], all=True), key=lambda frame: (frame["timestamp"], frame["pk"]))
+    if not frames:
+        return None, None
+    reference, _ = _nearest_pair(frames, [{"pk": capture.pk, "timestamp": capture.timestamp}])
+    relation, _ = _relation(frames[0]["timestamp"], frames[-1]["timestamp"], capture.timestamp, capture.timestamp)
+    return reference, relation
+
+
+def match_capture_detections(occurrence: Occurrence, capture: SourceImage) -> dict[str, Any]:
+    """Every real box on ``capture`` scored against ``occurrence``'s track the way tracking scores it.
+
+    The reference is the track frame nearest in time on another capture. The tracker's own
+    matcher runs between every box on the reference frame's capture and every box on
+    ``capture``, with the tracker's default settings, feature algorithm and image diagonal,
+    and ``would_link`` marks the box it links the reference frame to. Tracking only pairs
+    adjacent captures, so across a longer gap this previews its pairing rule, not a run.
+
+    The track's own box is returned unscored. So is every box when the track has no other
+    frame, or when the earlier of the two captures has no dimensions, since tracking skips
+    such a pair of captures. The query count is fixed, whatever the track's length or the
+    number of boxes.
+    """
+    from ami.main.models import Classification, Detection, SourceImage
+    from ami.ml.models import Algorithm
+    from ami.ml.post_processing.tracking_task import (
+        image_diagonal,
+        latest_feature_vectors,
+        resolve_feature_algorithm,
+        select_links,
+    )
+
+    config = tracking_config_for(occurrence)
+    reference, relation = _reference_frame(occurrence.pk, capture) if capture.timestamp else (None, None)
+    reference_capture_id = reference["source_image_id"] if reference is not None else None
+    detections = list(
+        Detection.objects.valid()
+        .filter(source_image_id__in=[capture.pk] + ([reference_capture_id] if reference_capture_id else []))
+        .only("pk", "bbox", "occurrence_id", "source_image_id")
+        .order_by("pk")
+    )
+    boxes = [detection for detection in detections if detection.source_image_id == capture.pk]
+    if reference is not None and any(box.occurrence_id == occurrence.pk for box in boxes):
+        relation = RELATION_SAME
+
+    # Tracking takes the one extractor with embeddings anywhere in the session, which scans
+    # every classification (about 40 ms). The two captures being paired give the same answer
+    # unless a session mixes extractors.
+    detection_ids = [detection.pk for detection in detections]
+    extractor_ids = set(
+        Classification.objects.filter(
+            detection_id__in=detection_ids, features_2048__isnull=False, algorithm_id__isnull=False
+        )
+        .order_by()
+        .values_list("algorithm_id", flat=True)
+        .distinct()
+    )
+    extractors = list(Algorithm.objects.filter(pk__in=extractor_ids))
+    algorithm, _, _ = resolve_feature_algorithm(occurrence.event, config, candidates=extractors)
+    vectors = latest_feature_vectors(detection_ids, algorithm.pk) if algorithm is not None else {}
+
+    def skipped(detection_id: int) -> str | None:
+        return SKIPPED_NO_VECTOR if config.require_features and detection_id not in vectors else None
+
+    diag, linked, reference_detection = None, set(), None
+    if reference is not None:
+        reference_detection = next(d for d in detections if d.pk == reference["pk"])
+        reference_boxes = [d for d in detections if d.source_image_id == reference_capture_id]
+        capture_first = (capture.timestamp, capture.pk) < (reference["timestamp"], reference_capture_id)
+        width, height = (
+            (capture.width, capture.height)
+            if capture_first
+            else (reference["source_image__width"], reference["source_image__height"])
+        )
+        if width and height:
+            diag = image_diagonal(width, height)
+            current, following = (boxes, reference_boxes) if capture_first else (reference_boxes, boxes)
+            links = select_links(current, following, vectors, diag, config.cost_threshold, config.require_features)
+            linked = {frozenset((det.pk, nxt.pk)) for det, nxt, _ in links}
+
+    # Captures from the reference frame's to this one, signed: 1 is the adjacent capture the
+    # tracker would pair, so a larger count means the preview spans captures it never compares.
+    capture_offset = None
+    if reference is not None:
+        (low_ts, low_pk), (high_ts, high_pk) = sorted(
+            [(reference["timestamp"], reference_capture_id), (capture.timestamp, capture.pk)]
+        )
+        # The occurrence's session, not the capture's: the view loads the capture with
+        # ``only()`` and reading ``capture.event_id`` would cost a query.
+        between = (
+            SourceImage.objects.filter(event_id=occurrence.event_id, timestamp__gte=low_ts, timestamp__lte=high_ts)
+            .exclude(timestamp=low_ts, pk__lte=low_pk)
+            .exclude(timestamp=high_ts, pk__gt=high_pk)
+            .count()
+        )
+        capture_offset = (
+            between if (capture.timestamp, capture.pk) > (reference["timestamp"], reference_capture_id) else -between
+        )
+
+    rows: list[dict[str, Any]] = []
+    for box in boxes:
+        in_track = box.occurrence_id == occurrence.pk
+        row = {
+            "detection_id": box.pk,
+            "occurrence_id": box.occurrence_id,
+            "in_track": in_track,
+            "would_link": reference is not None and frozenset((reference["pk"], box.pk)) in linked,
+            "skipped_reason": skipped(box.pk),
+        }
+        row.update(dict.fromkeys(_MATCH_SCORE_FIELDS))
+        if reference is not None and not in_track:
+            row["time_offset_seconds"] = (capture.timestamp - reference["timestamp"]).total_seconds()
+            if diag is not None:
+                row.update(
+                    _pair_scores(
+                        reference_detection.bbox,
+                        box.bbox,
+                        vectors.get(reference["pk"]),
+                        vectors.get(box.pk),
+                        diag,
+                    )
+                )
+        rows.append(row)
+    rows.sort(key=lambda row: (row["likelihood"] is None, -(row["likelihood"] or 0.0), row["detection_id"]))
+
+    return {
+        "capture_id": capture.pk,
+        "cost_threshold": config.cost_threshold,
+        "feature_algorithm_id": algorithm.pk if algorithm is not None else None,
+        "requires_features": config.require_features,
+        "reference": (
+            {
+                "detection_id": reference["pk"],
+                "capture_id": reference_capture_id,
+                "timestamp": reference["timestamp"],
+                "relation": relation,
+                "capture_offset": capture_offset,
+                "skipped_reason": skipped(reference["pk"]),
+            }
+            if reference is not None
+            else None
+        ),
+        "detections": rows,
+    }
diff --git a/ami/main/models_future/occurrence.py b/ami/main/models_future/occurrence.py
index ad5cc0ac6..139ff2630 100644
--- a/ami/main/models_future/occurrence.py
+++ b/ami/main/models_future/occurrence.py
@@ -11,6 +11,7 @@
 from __future__ import annotations
 
 import collections
+import datetime
 from typing import TYPE_CHECKING
 
 from django.db.models import Count, OuterRef, Prefetch, Q, QuerySet, Subquery
@@ -19,10 +20,14 @@
 from ami.utils.stats import cohens_kappa, wilson_interval
 
 if TYPE_CHECKING:
-    from ami.main.models import Classification, Identification, Occurrence
+    from ami.main.models import Classification, Detection, Identification, Occurrence
 
 TaxonTuple = tuple[int, str, list[dict]]
 
+# Frames per page of an occurrence's detections, in the detail response and the
+# paginated detections endpoint alike, so the detail's frames are that endpoint's first page.
+OCCURRENCE_FRAMES_PAGE_SIZE = 20
+
 
 def lca_rank_between(a: TaxonTuple, b: TaxonTuple) -> TaxonRank | None:
     """Most-specific shared ancestor rank between two taxa.
@@ -52,20 +57,32 @@ def lca_rank_between(a: TaxonTuple, b: TaxonTuple) -> TaxonRank | None:
     return deepest
 
 
+def prefetch_nested_classifications() -> Prefetch:
+    """Classifications as the nested serializers render them.
+
+    Joins the taxon, algorithm and provenance parent so no query fires per row, and
+    annotates ``has_features`` in place of the embedding, which is never loaded.
+    """
+    from ami.main.models import Classification
+
+    # Post-processed classifications (class masking, rank rollup) render their
+    # provenance parent, so join it rather than query per row. The parent is a
+    # self-join, so its embedding has to be deferred by name as well.
+    queryset = (
+        Classification.objects.select_related("taxon", "algorithm", "applied_to__algorithm")
+        .defer("applied_to__features_2048")
+        .with_has_features()
+    )
+    return Prefetch("classifications", queryset=queryset)
+
+
 def _detections_prefetch(*, ordering: tuple[str, ...], with_source_image: bool) -> Prefetch:
-    from ami.main.models import Classification, Detection
-
-    qs = Detection.objects.prefetch_related(
-        Prefetch(
-            "classifications",
-            # applied_to__algorithm: post-processed classifications (class masking,
-            # rank rollup) serialize their provenance parent; pull it here so the
-            # nested applied_to render doesn't issue a query per classification.
-            queryset=Classification.objects.select_related("taxon", "algorithm", "applied_to__algorithm"),
-        )
-    ).order_by(*ordering)
+    from ami.main.models import Detection
+
+    qs = Detection.objects.prefetch_related(prefetch_nested_classifications()).order_by(*ordering)
     if with_source_image:
-        qs = qs.select_related("source_image")
+        # The capture's URL is built from its deployment's data source.
+        qs = qs.select_related("source_image__deployment__data_source")
     return Prefetch("detections", queryset=qs)
 
 
@@ -83,6 +100,29 @@ def prefetch_detections_for_detail() -> Prefetch:
     return _detections_prefetch(ordering=("-timestamp",), with_source_image=True)
 
 
+def _frame_order_key(detection: Detection) -> tuple:
+    """``tracks.CAPTURE_ORDER`` for a detection with its source_image loaded."""
+    timestamp = detection.source_image.timestamp
+    return (timestamp is None, timestamp or datetime.datetime.min, detection.source_image_id, detection.pk)
+
+
+def frames_from_prefetch(occurrence: Occurrence) -> list[Detection]:
+    """The prefetched detections in frame order, each with its ``frame_index`` set.
+
+    Frame order is the capture order the track edits and the tracks export use, so a
+    frame's index matches the one the paginated detections endpoint reports. Strict:
+    requires `detections` prefetched with their source_image.
+    """
+    frames = getattr(occurrence, "_frames_in_order", None)
+    if frames is None:
+        _require_prefetch(occurrence, "detections")
+        frames = sorted(occurrence.detections.all(), key=_frame_order_key)
+        for index, detection in enumerate(frames):
+            detection.frame_index = index
+        occurrence._frames_in_order = frames
+    return frames
+
+
 def _require_prefetch(occurrence: Occurrence, *relations: str) -> None:
     """Raise if any required top-level relation is missing from the prefetch cache.
 
@@ -168,6 +208,48 @@ def detection_image_urls_from_prefetch(occurrence: Occurrence, limit: int | None
     return [get_media_url(det.path) for det in detections]
 
 
+def occurrence_path(occurrence: Occurrence) -> list[dict]:
+    """Where this occurrence was in every frame it appears in, earliest first.
+
+    A drawing payload: enough to place each frame's box on any other frame of the
+    same session, and to draw that frame's crop inside the box. The capture's
+    dimensions are the part no other payload carries, and a box cannot be placed
+    without them because it is measured in the pixel space of its own capture,
+    which need not match the one on screen. ``crop_url`` is null for a detection
+    whose crop has not been generated.
+
+    Ordered by the capture's timestamp rather than ``Detection.timestamp``, which is
+    copied from it but is nullable. The two agree wherever the copy has been made,
+    so this is the same order ``split_track`` acts on.
+    """
+    from ami.main.models import get_media_url
+
+    rows = occurrence.detections.order_by("source_image__timestamp", "pk").values(
+        "pk",
+        "bbox",
+        "path",
+        "source_image_id",
+        "source_image__timestamp",
+        "source_image__width",
+        "source_image__height",
+    )
+
+    return [
+        {
+            "detection_id": row["pk"],
+            "bbox": row["bbox"],
+            "crop_url": get_media_url(row["path"]) if row["path"] else None,
+            "capture": {
+                "id": row["source_image_id"],
+                "timestamp": row["source_image__timestamp"],
+                "width": row["source_image__width"],
+                "height": row["source_image__height"],
+            },
+        }
+        for row in rows
+    ]
+
+
 def model_agreement_for_project(
     queryset: QuerySet[Occurrence],
     coarsest_rank: TaxonRank | None = None,
diff --git a/ami/main/models_future/track_stats.py b/ami/main/models_future/track_stats.py
new file mode 100644
index 000000000..a126ae4cb
--- /dev/null
+++ b/ami/main/models_future/track_stats.py
@@ -0,0 +1,419 @@
+"""Per-occurrence track statistics: how far a tracked insect moved, how much its box
+changed, and how consistently it was labelled.
+
+One set of definitions, two homes. Four of the numbers are stored on the occurrence row
+(``Occurrence.track_*``) so the list endpoint can sort by them; ``refresh_track_stats``
+recomputes them in SQL whenever tracking or a track edit changes which detections an
+occurrence holds, and ``backfill_track_stats`` fills in rows from before the fields
+existed. The detail endpoint computes the same numbers live, in Python, from the
+detections it has already prefetched, so its card always describes the current row.
+
+Definitions:
+- ``frames``: detections in the occurrence.
+- ``motion``: path length between consecutive detection centres, ordered by
+  (timestamp, id), divided by the frame diagonal. A stationary insect scores ~0.
+- ``size_ratio``: largest bbox area over smallest, areas floored at 1.0.
+- ``distinct_taxa``: distinct taxa among terminal classifications, across every
+  algorithm, so two classifiers that disagree count as two taxa.
+- ``id_agreement``: share of terminal classifications naming the determination;
+  null when there are none.
+
+The frame diagonal is taken from the largest capture width and height seen; when the
+captures carry no dimensions it falls back to the farthest bbox corner, and to 1.0 when
+that is also unknown. Stats are returned for single-detection occurrences as well
+(motion 0.0, size_ratio 1.0), so the payload has one shape.
+"""
+
+from __future__ import annotations
+
+import math
+import statistics
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from django.db import connection
+
+if TYPE_CHECKING:
+    from ami.main.models import Detection, Occurrence
+
+TRACK_STATS_KEYS = ("frames", "motion", "size_ratio", "distinct_taxa", "id_agreement")
+
+# The stored subset, in the order the Occurrence fields are declared. ``frames`` is not
+# stored: the list already annotates ``detections_count``.
+TRACK_STAT_FIELDS = ("track_motion", "track_size_ratio", "track_distinct_taxa", "track_id_agreement")
+
+# Ids per statement when refreshing many rows; keeps the ``ANY(%s)`` arrays and the
+# CASE expression ``bulk_update`` builds to a size Postgres plans quickly.
+REFRESH_BATCH_SIZE = 500
+
+_MIN_AREA = 1.0
+_ROUND_TO = 4
+
+
+def frame_diagonal(
+    max_width: float | None, max_height: float | None, max_x2: float | None, max_y2: float | None
+) -> float:
+    """Length motion is normalised by, in the same pixel units as the bboxes."""
+    if max_width and max_height:
+        return math.hypot(max_width, max_height)
+    if max_x2 or max_y2:
+        return math.hypot(max_x2 or 0.0, max_y2 or 0.0) or 1.0
+    return 1.0
+
+
+def size_ratio(min_area: float | None, max_area: float | None) -> float:
+    if not min_area or not max_area:
+        return 1.0
+    return round(max_area / min_area, _ROUND_TO)
+
+
+def id_agreement(agreeing: int, terminal_count: int) -> float | None:
+    if terminal_count == 0:
+        return None
+    return round(agreeing / terminal_count, _ROUND_TO)
+
+
+def bbox_corners(bbox) -> tuple[float, float, float, float] | None:
+    if not bbox or len(bbox) < 4:
+        return None
+    try:
+        return tuple(float(v) for v in bbox[:4])  # type: ignore[return-value]
+    except (TypeError, ValueError):
+        return None
+
+
+def _detection_order_key(detection: Detection) -> tuple:
+    # Same order as the SQL window: timestamp ascending, nulls last, then id. A None
+    # timestamp is never compared against a datetime because the leading flag differs.
+    return (detection.timestamp is None, detection.timestamp, detection.pk)
+
+
+def _geometry_from_detections(detections: list[Detection]) -> tuple[float, float]:
+    """(motion, size_ratio) over detections that are already sorted into track order."""
+    path_length = 0.0
+    prev_centre: tuple[float, float] | None = None
+    min_area: float | None = None
+    max_area: float | None = None
+    max_width: int | None = None
+    max_height: int | None = None
+    max_x2: float | None = None
+    max_y2: float | None = None
+
+    for detection in detections:
+        corners = bbox_corners(detection.bbox)
+        if corners is None:
+            prev_centre = None
+            continue
+        x1, y1, x2, y2 = corners
+        centre = ((x1 + x2) / 2.0, (y1 + y2) / 2.0)
+        if prev_centre is not None:
+            path_length += math.dist(prev_centre, centre)
+        prev_centre = centre
+
+        area = max(abs((x2 - x1) * (y2 - y1)), _MIN_AREA)
+        min_area = area if min_area is None else min(min_area, area)
+        max_area = area if max_area is None else max(max_area, area)
+        max_x2 = x2 if max_x2 is None else max(max_x2, x2)
+        max_y2 = y2 if max_y2 is None else max(max_y2, y2)
+
+        source_image = getattr(detection, "source_image", None)
+        if source_image is not None:
+            if source_image.width:
+                max_width = max(max_width or 0, source_image.width)
+            if source_image.height:
+                max_height = max(max_height or 0, source_image.height)
+
+    diagonal = frame_diagonal(max_width, max_height, max_x2, max_y2)
+    return round(path_length / diagonal, _ROUND_TO), size_ratio(min_area, max_area)
+
+
+def _classification_stats(
+    terminal_taxon_ids: Iterable[int | None], determination_id: int | None
+) -> tuple[int, float | None]:
+    """(distinct_taxa, id_agreement). A classification with no taxon never agrees."""
+    taxon_ids = list(terminal_taxon_ids)
+    distinct = len({taxon_id for taxon_id in taxon_ids if taxon_id is not None})
+    agreeing = sum(1 for taxon_id in taxon_ids if taxon_id is not None and taxon_id == determination_id)
+    return distinct, id_agreement(agreeing, len(taxon_ids))
+
+
+def track_stats_from_detections(detections: Iterable[Detection], determination_id: int | None) -> dict:
+    """The list-endpoint stats, computed in Python from prefetched detections.
+
+    Each detection's ``classifications`` must be prefetched and ``source_image``
+    select_related, or this issues a query per detection.
+    """
+    ordered = sorted(detections, key=_detection_order_key)
+    motion, ratio = _geometry_from_detections(ordered)
+    terminal_taxon_ids = [c.taxon_id for d in ordered for c in d.classifications.all() if c.terminal]
+    distinct, agreement = _classification_stats(terminal_taxon_ids, determination_id)
+    return {
+        "frames": len(ordered),
+        "motion": motion,
+        "size_ratio": ratio,
+        "distinct_taxa": distinct,
+        "id_agreement": agreement,
+    }
+
+
+# One row per occurrence: frame count, summed centre-to-centre distance in track order,
+# and the extremes the diagonal and size ratio are derived from. The CASE keeps a
+# detection without a bbox out of the area extremes instead of flooring it to 1.0.
+_GEOMETRY_SQL = """
+WITH frames AS (
+    SELECT
+        d.occurrence_id,
+        d.id,
+        d.timestamp,
+        (d.bbox->>0)::float AS x1,
+        (d.bbox->>1)::float AS y1,
+        (d.bbox->>2)::float AS x2,
+        (d.bbox->>3)::float AS y2,
+        si.width,
+        si.height
+    FROM {detection} d
+    LEFT JOIN {source_image} si ON si.id = d.source_image_id
+    WHERE d.occurrence_id = ANY(%s)
+),
+steps AS (
+    SELECT
+        occurrence_id,
+        (x1 + x2) / 2.0 AS cx,
+        (y1 + y2) / 2.0 AS cy,
+        LAG((x1 + x2) / 2.0) OVER track AS prev_cx,
+        LAG((y1 + y2) / 2.0) OVER track AS prev_cy,
+        CASE WHEN x1 IS NULL THEN NULL ELSE GREATEST(ABS((x2 - x1) * (y2 - y1)), {min_area}) END AS area,
+        x2,
+        y2,
+        width,
+        height
+    FROM frames
+    WINDOW track AS (PARTITION BY occurrence_id ORDER BY timestamp, id)
+)
+SELECT
+    occurrence_id,
+    COUNT(*) AS frames,
+    COALESCE(SUM(SQRT(POWER(cx - prev_cx, 2) + POWER(cy - prev_cy, 2))), 0.0) AS path_length,
+    MIN(area) AS min_area,
+    MAX(area) AS max_area,
+    MAX(width) AS max_width,
+    MAX(height) AS max_height,
+    MAX(x2) AS max_x2,
+    MAX(y2) AS max_y2
+FROM steps
+GROUP BY occurrence_id
+"""
+
+# One row per occurrence that has terminal classifications.
+_CLASSIFICATION_SQL = """
+SELECT
+    d.occurrence_id,
+    COUNT(DISTINCT c.taxon_id) AS distinct_taxa,
+    COUNT(*) AS terminal_count,
+    COUNT(*) FILTER (WHERE c.taxon_id = o.determination_id) AS agreeing
+FROM {classification} c
+JOIN {detection} d ON d.id = c.detection_id
+JOIN {occurrence} o ON o.id = d.occurrence_id
+WHERE d.occurrence_id = ANY(%s) AND c.terminal
+GROUP BY d.occurrence_id
+"""
+
+
+def track_stats_for_occurrences(occurrence_ids: list[int]) -> dict[int, dict]:
+    """Stats keyed by occurrence id, in two statements scoped to the ids given.
+
+    Occurrences with no detections are absent from the result. The cost is proportional
+    to the detections behind the ids, not to the project, so keep a call to a page or a
+    refresh batch of ids.
+    """
+    from ami.main.models import Classification, Detection, Occurrence, SourceImage
+
+    if not occurrence_ids:
+        return {}
+
+    geometry_sql = _GEOMETRY_SQL.format(
+        detection=Detection._meta.db_table,
+        source_image=SourceImage._meta.db_table,
+        min_area=_MIN_AREA,
+    )
+    classification_sql = _CLASSIFICATION_SQL.format(
+        classification=Classification._meta.db_table,
+        detection=Detection._meta.db_table,
+        occurrence=Occurrence._meta.db_table,
+    )
+
+    stats: dict[int, dict] = {}
+    with connection.cursor() as cursor:
+        cursor.execute(geometry_sql, [list(occurrence_ids)])
+        for pk, frames, path_length, min_area, max_area, max_width, max_height, max_x2, max_y2 in cursor.fetchall():
+            diagonal = frame_diagonal(max_width, max_height, max_x2, max_y2)
+            stats[pk] = {
+                "frames": frames,
+                "motion": round(float(path_length) / diagonal, _ROUND_TO),
+                "size_ratio": size_ratio(min_area, max_area),
+                "distinct_taxa": 0,
+                "id_agreement": None,
+            }
+
+        cursor.execute(classification_sql, [list(occurrence_ids)])
+        for pk, distinct, terminal_count, agreeing in cursor.fetchall():
+            if pk in stats:
+                stats[pk]["distinct_taxa"] = distinct
+                stats[pk]["id_agreement"] = id_agreement(agreeing, terminal_count)
+
+    return stats
+
+
+def stored_track_stats(occurrence: Occurrence, frames: int) -> dict | None:
+    """The list payload, read from the stored fields; None until they have been computed.
+
+    ``track_motion`` is never null once stored (a single frame scores 0.0), so it stands
+    in for all four. ``frames`` comes from the caller's ``detections_count`` annotation.
+    """
+    if occurrence.track_motion is None:
+        return None
+    return {
+        "frames": frames,
+        "motion": occurrence.track_motion,
+        "size_ratio": occurrence.track_size_ratio,
+        "distinct_taxa": occurrence.track_distinct_taxa,
+        "id_agreement": occurrence.track_id_agreement,
+    }
+
+
+def _apply_stats(occurrence: Occurrence, stats: dict | None) -> None:
+    occurrence.track_motion = stats["motion"] if stats else None
+    occurrence.track_size_ratio = stats["size_ratio"] if stats else None
+    occurrence.track_distinct_taxa = stats["distinct_taxa"] if stats else None
+    occurrence.track_id_agreement = stats["id_agreement"] if stats else None
+
+
+def refresh_track_stats(*occurrences: Occurrence) -> None:
+    """Recompute the stored stats for these occurrences from their current detections.
+
+    Three queries however many occurrences are given: the two statements of
+    ``track_stats_for_occurrences`` and one ``bulk_update``. The instances are updated in
+    place as well as the rows. An occurrence with no detections is set back to null.
+    Call after the determination is settled, since ``id_agreement`` is measured against
+    it, and without going through ``Occurrence.save()``, which would recompute it.
+    """
+    from ami.main.models import Occurrence
+
+    targets = [occurrence for occurrence in occurrences if occurrence.pk is not None]
+    if not targets:
+        return
+    stats = track_stats_for_occurrences([occurrence.pk for occurrence in targets])
+    for occurrence in targets:
+        _apply_stats(occurrence, stats.get(occurrence.pk))
+    Occurrence.objects.bulk_update(targets, TRACK_STAT_FIELDS)
+
+
+def refresh_track_stats_for_ids(occurrence_ids: Iterable[int]) -> int:
+    """Refresh stored stats by id, in batches of ``REFRESH_BATCH_SIZE``; returns the count.
+
+    Writes through ``bulk_update`` so ``updated_at`` is left alone: the list sorts by it
+    by default, and a backfill must not reorder every occurrence in a project.
+    """
+    from ami.main.models import Occurrence
+
+    ids = list(occurrence_ids)
+    for start in range(0, len(ids), REFRESH_BATCH_SIZE):
+        refresh_track_stats(*(Occurrence(pk=pk) for pk in ids[start : start + REFRESH_BATCH_SIZE]))
+    return len(ids)
+
+
+def tracking_algorithm_summary() -> dict | None:
+    """The Algorithm row the tracking task registers itself under, or None if it never ran here."""
+    from ami.ml.models.algorithm import Algorithm
+    from ami.ml.post_processing.tracking_task import TrackingTask
+
+    return Algorithm.objects.filter(key=TrackingTask.key).values("id", "name", "key").first()
+
+
+def _frame_label(detection: Detection):
+    """The classification a frame is labelled with, or None when none names a taxon.
+
+    Terminal classifications outrank intermediate ones such as a moth filter; then the
+    higher score wins, then the more recent. The frame strip applies the same rule.
+    """
+    named = [c for c in detection.classifications.all() if c.taxon_id is not None]
+    candidates = [c for c in named if c.terminal] or named
+    return max(
+        candidates,
+        key=lambda c: (c.score if c.score is not None else -1, c.created_at.timestamp() if c.created_at else 0),
+        default=None,
+    )
+
+
+def frame_names_from_detections(detections: Iterable[Detection]) -> list[dict]:
+    """Each distinct frame label across a track, with its frame count and best score.
+
+    Most frames first. Frames without a label are counted under a null taxon.
+    """
+    names: dict[int | None, dict] = {}
+    for detection in detections:
+        label = _frame_label(detection)
+        taxon = label.taxon if label else None
+        name = names.setdefault(
+            taxon.pk if taxon else None,
+            {
+                "taxon": {"id": taxon.pk, "name": taxon.name, "rank": taxon.rank} if taxon else None,
+                "frames": 0,
+                "score_max": None,
+            },
+        )
+        name["frames"] += 1
+        if label and label.score is not None and (name["score_max"] is None or label.score > name["score_max"]):
+            name["score_max"] = label.score
+    for name in names.values():
+        if name["score_max"] is not None:
+            name["score_max"] = round(name["score_max"], _ROUND_TO)
+    return sorted(
+        names.values(),
+        key=lambda n: (-n["frames"], -(n["score_max"] if n["score_max"] is not None else -1)),
+    )
+
+
+def grouping_summary_from_prefetch(occurrence: Occurrence, algorithm: dict | None) -> dict:
+    """Read-time description of how this occurrence's detections hang together.
+
+    ``derived`` is a fixed marker: these numbers are computed from the current
+    detections on every read, never stored and never exported. Requires
+    ``OccurrenceQuerySet.with_detail_prefetches()``: the detections with their
+    classifications and source_image, plus the ``frames_with_vectors`` annotation.
+    """
+    from ami.main.models_future.occurrence import _require_prefetch
+
+    _require_prefetch(occurrence, "detections")
+    frames_with_vectors = getattr(occurrence, "frames_with_vectors", None)
+    if frames_with_vectors is None:
+        raise RuntimeError(
+            f"Occurrence {occurrence.pk} is missing the frames_with_vectors annotation. "
+            "Apply OccurrenceQuerySet.with_detail_prefetches() in the viewset's get_queryset()."
+        )
+    detections = list(occurrence.detections.all())
+    member_ids = {d.pk for d in detections}
+    stats = track_stats_from_detections(detections, occurrence.determination_id)
+
+    timestamps = [d.timestamp for d in detections if d.timestamp is not None]
+    duration = (max(timestamps) - min(timestamps)).total_seconds() if timestamps else None
+
+    scores = [c.score for d in detections for c in d.classifications.all() if c.terminal and c.score is not None]
+
+    return {
+        "derived": True,
+        "algorithm": algorithm,
+        "frames": stats["frames"],
+        "frames_with_vectors": frames_with_vectors,
+        # A link into another occurrence joins the pieces of a track split at a session boundary.
+        "linked_detections": sum(1 for d in detections if d.next_detection_id in member_ids),
+        "duration_seconds": duration,
+        "motion": stats["motion"],
+        "size_ratio": stats["size_ratio"],
+        "distinct_taxa": stats["distinct_taxa"],
+        "id_agreement": stats["id_agreement"],
+        "score_min": round(min(scores), _ROUND_TO) if scores else None,
+        "score_mean": round(statistics.fmean(scores), _ROUND_TO) if scores else None,
+        "score_max": round(max(scores), _ROUND_TO) if scores else None,
+        "frame_names": frame_names_from_detections(detections),
+    }
diff --git a/ami/main/models_future/tracks.py b/ami/main/models_future/tracks.py
new file mode 100644
index 000000000..27211070f
--- /dev/null
+++ b/ami/main/models_future/tracks.py
@@ -0,0 +1,637 @@
+"""Operations for correcting a track after tracking has grouped it.
+
+A track is a run of detections that tracking decided are the same insect, all
+attached to one occurrence and linked in time order through
+``Detection.next_detection``.
+
+Tracking errs toward leaving one animal as two occurrences rather than merging
+two animals into one, because a wrong merge destroys a record that no later
+step recovers. These operations are the repair for the merges it still gets
+wrong: cut a track in two, or pull a single detection out of it.
+
+All operations work on the occurrence's detections in capture order, which is
+what the occurrence view shows. That means they behave sensibly on occurrences
+that were never tracked and so carry no links at all.
+
+Five invariants hold after every operation here:
+
+- Every occurrence the edit touched is linked frame to frame in capture order within
+  each session (``relink_occurrence_chains``), so a confirmed track exports as one
+  unbroken chain.
+- A chain link never crosses an occurrence boundary within one session. Otherwise
+  a later tracking pass would walk the chain, decide both occurrences are one, and
+  undo the edit. Tracking stops at session boundaries, so the link a regroup keeps
+  between the pieces of a track it split (``split_at_session_boundaries``) is safe.
+- An edit that changes which detections an occurrence holds clears its grouping
+  verification. A person confirmed the set they were shown, not a later one.
+- The stored track statistics of every surviving occurrence the edit touched are
+  recomputed, so the list sorts on current numbers. This costs three queries per
+  edit however many occurrences it touched (see ``track_stats.refresh_track_stats``).
+- The cached counts of the sessions and stations the edit touched are refreshed once,
+  since an edit adds or removes occurrences.
+
+Every edit, and every tracking run, first locks the session it changes
+(``lock_sessions``), so an edit made during a run waits for the run to finish
+instead of being overwritten by it.
+"""
+
+from __future__ import annotations
+
+import datetime
+import itertools
+from collections import Counter
+from collections.abc import Iterable
+
+import psycopg.errors
+from django.db import OperationalError, connection, transaction
+from django.db.models import F
+from django.utils import timezone
+
+from ami.main.models import (
+    Detection,
+    Event,
+    Identification,
+    Occurrence,
+    SourceImage,
+    User,
+    update_calculated_fields_for_sessions_and_stations,
+    update_occurrence_determination,
+)
+from ami.main.models_future.track_stats import refresh_track_stats
+
+# Frame order within a track: capture time, then capture, then detection. The edits,
+# the chain links and the tracks export all use it, so they agree on what "next" is.
+CAPTURE_ORDER = (F("source_image__timestamp").asc(nulls_last=True), "source_image_id", "pk")
+
+
+def _capture_order_key(row: dict) -> tuple:
+    """``CAPTURE_ORDER`` for a detection row read with ``.values()``."""
+    timestamp = row["source_image__timestamp"]
+    return (timestamp is None, timestamp or datetime.datetime.min, row["source_image_id"], row["pk"])
+
+
+class TrackEditError(ValueError):
+    """A track edit that cannot be applied to this occurrence and detection."""
+
+
+class SessionBusy(TrackEditError):
+    """A track edit that gave up waiting for a tracking run on the same session."""
+
+
+# How long an edit waits for a tracking run to release the session. A run can hold it for
+# minutes, and a request left waiting that long fails at the web server with no message.
+EDIT_LOCK_TIMEOUT_MS = 5000
+
+
+def lock_sessions(event_ids: Iterable[int | None], timeout_ms: int | None = None) -> None:
+    """Hold a row lock on each session until the surrounding transaction ends.
+
+    Tracking runs and track edits both call this before reading what they change, so
+    one waits for the other. Locking in id order keeps two writers from deadlocking.
+    With ``timeout_ms``, raises ``SessionBusy`` instead of waiting longer than that.
+    """
+    pks = sorted({pk for pk in event_ids if pk is not None})
+    if not pks:
+        return
+    if timeout_ms is not None:
+        with connection.cursor() as cursor:
+            cursor.execute(f"SET LOCAL lock_timeout = {int(timeout_ms)}")
+    try:
+        list(Event.objects.select_for_update().filter(pk__in=pks).order_by("pk").values_list("pk", flat=True))
+    except OperationalError as e:
+        if isinstance(e.__cause__, psycopg.errors.LockNotAvailable):
+            raise SessionBusy("Tracking is running on this session; try again when it finishes.") from e
+        raise
+
+
+def _lock_for_edit(*occurrences: Occurrence, detections: Iterable[Detection] = ()) -> None:
+    """Lock the sessions of ``occurrences``, then re-read what a tracking run may have changed.
+
+    The caller loaded these rows before waiting on the lock, and saving them as loaded
+    would write a finished run's changes back over.
+    """
+    lock_sessions((o.event_id for o in occurrences), timeout_ms=EDIT_LOCK_TIMEOUT_MS)
+    for occurrence in occurrences:
+        try:
+            occurrence.refresh_from_db()
+        except Occurrence.DoesNotExist:
+            raise TrackEditError(f"Occurrence {occurrence.pk} no longer exists; it was merged while this edit waited.")
+    detections = list(detections)
+    if detections:
+        current = dict(Detection.objects.filter(pk__in=[d.pk for d in detections]).values_list("pk", "occurrence_id"))
+        for detection in detections:
+            detection.occurrence_id = current.get(detection.pk)
+
+
+def _ordered_detections(occurrence: Occurrence) -> list[Detection]:
+    return list(occurrence.detections.select_related("source_image").order_by(*CAPTURE_ORDER))
+
+
+def _move_to_new_occurrence(occurrence: Occurrence, detections: list[Detection]) -> Occurrence:
+    """Attach ``detections``, in time order, to a new occurrence beside ``occurrence``.
+
+    The new occurrence takes the session of its first detection's capture, which after a
+    regroup need not be the session of ``occurrence``.
+    """
+    new_occurrence = Occurrence.objects.create(
+        event_id=detections[0].source_image.event_id,
+        deployment=occurrence.deployment,
+        project=occurrence.project,
+    )
+    Detection.objects.filter(pk__in=[d.pk for d in detections]).update(occurrence=new_occurrence)
+    return new_occurrence
+
+
+@transaction.atomic
+def split_track(occurrence: Occurrence, detection: Detection) -> Occurrence:
+    """Split ``occurrence`` so ``detection`` and everything after it become a new occurrence.
+
+    Use when a track ran two animals together: the frame where the second one
+    takes over is the split point. Returns the new occurrence holding the tail.
+
+    "After" means later in time. Note that the occurrence detail endpoint
+    serves detections newest-first (prefetch_detections_for_detail), so an
+    interface that splits at the frame the operator clicked must map the
+    displayed position back to capture order, or it will keep the wrong half.
+    """
+    _lock_for_edit(occurrence)
+    ordered = _ordered_detections(occurrence)
+    index = next((i for i, d in enumerate(ordered) if d.pk == detection.pk), None)
+    if index is None:
+        raise TrackEditError(f"Detection {detection.pk} does not belong to occurrence {occurrence.pk}.")
+    if index == 0:
+        raise TrackEditError(
+            f"Detection {detection.pk} is the first in occurrence {occurrence.pk}; "
+            "there is nothing before it to split from."
+        )
+
+    new_occurrence = _move_to_new_occurrence(occurrence, ordered[index:])
+    relink_occurrence_chains([occurrence, new_occurrence])
+
+    clear_grouping_verification(occurrence, new_occurrence)
+    occurrence.save()
+    new_occurrence.save()
+    refresh_track_stats(occurrence, new_occurrence)
+    update_calculated_fields_for_sessions_and_stations([occurrence.event_id, new_occurrence.event_id])
+    return new_occurrence
+
+
+@transaction.atomic
+def detach_detection(occurrence: Occurrence, detection: Detection) -> Occurrence:
+    """Pull one detection out of ``occurrence`` into an occurrence of its own.
+
+    Use when a single frame was matched into the wrong track. The rest of the
+    track is stitched back together across the gap, so removing a detection from
+    the middle does not also split what remains. Returns the new occurrence.
+    """
+    _lock_for_edit(occurrence)
+    ordered = _ordered_detections(occurrence)
+    if len(ordered) < 2:
+        raise TrackEditError(
+            f"Occurrence {occurrence.pk} has a single detection; removing it would leave the occurrence empty."
+        )
+    index = next((i for i, d in enumerate(ordered) if d.pk == detection.pk), None)
+    if index is None:
+        raise TrackEditError(f"Detection {detection.pk} does not belong to occurrence {occurrence.pk}.")
+
+    new_occurrence = _move_to_new_occurrence(occurrence, [ordered[index]])
+    relink_occurrence_chains([occurrence, new_occurrence], moved_from={detection.pk: occurrence.pk})
+
+    clear_grouping_verification(occurrence, new_occurrence)
+    occurrence.save()
+    new_occurrence.save()
+    refresh_track_stats(occurrence, new_occurrence)
+    update_calculated_fields_for_sessions_and_stations([occurrence.event_id, new_occurrence.event_id])
+    return new_occurrence
+
+
+@transaction.atomic
+def split_at_session_boundaries(occurrence: Occurrence) -> list[Occurrence]:
+    """Split an occurrence whose detections fall in several sessions into one per session.
+
+    Regrouping captures into sessions can draw a boundary through a track, and an
+    occurrence is expected to belong to one session. The piece in the earliest session
+    keeps this occurrence and its identifications; each later piece is a new occurrence
+    holding copies of them. Unlike a manual split, every piece keeps the grouping
+    confirmation and the chain link to the next piece, since each piece is still the
+    whole track within its session and the link records that they are one animal.
+    Returns the new occurrences in time order, or an empty list when nothing was split.
+    """
+    # Waits without a timeout, as a tracking run does: a regroup is a background job too.
+    sessions = SourceImage.objects.filter(detections__occurrence=occurrence).values_list("event_id", flat=True)
+    lock_sessions([occurrence.event_id, *sessions])
+    try:
+        occurrence.refresh_from_db()
+    except Occurrence.DoesNotExist:
+        return []
+    detections = occurrence.detections.select_related("source_image").order_by(*CAPTURE_ORDER)
+    by_session: dict[int, list[Detection]] = {}
+    for detection in detections:
+        # A capture with no session stays with the earliest piece.
+        if detection.source_image.event_id is not None:
+            by_session.setdefault(detection.source_image.event_id, []).append(detection)
+    if len(by_session) < 2:
+        return []
+
+    earliest_event_id, *later_event_ids = by_session
+    pieces = [_move_to_new_occurrence(occurrence, by_session[event_id]) for event_id in later_event_ids]
+    piece_pks = [piece.pk for piece in pieces]
+
+    if occurrence.event_id != earliest_event_id:
+        occurrence.event_id = earliest_event_id
+        Occurrence.objects.filter(pk=occurrence.pk).update(event_id=earliest_event_id)
+    if occurrence.grouping_verified_at is not None:
+        for piece in pieces:
+            piece.grouping_verified_at = occurrence.grouping_verified_at
+            piece.grouping_verified_by_id = occurrence.grouping_verified_by_id
+        Occurrence.objects.filter(pk__in=piece_pks).update(
+            grouping_verified_at=occurrence.grouping_verified_at,
+            grouping_verified_by_id=occurrence.grouping_verified_by_id,
+        )
+
+    _copy_identifications(occurrence, pieces)
+    for piece in [occurrence, *pieces]:
+        update_occurrence_determination(piece, save=True)
+    refresh_track_stats(occurrence, *pieces)
+    return pieces
+
+
+def _copy_identifications(source: Occurrence, targets: list[Occurrence]) -> None:
+    """Give each target a copy of every identification on ``source``, dated as the original.
+
+    Written with ``bulk_create`` to skip ``Identification.save()``, which would withdraw
+    the user's other identifications on the target. The caller recomputes determinations.
+    """
+    originals = list(source.identifications.all())
+    if not originals or not targets:
+        return
+    note = f"Copied from occurrence {source.pk} when regrouping split it at a session boundary."
+    pairs = [(original, target) for target in targets for original in originals]
+    copies = Identification.objects.bulk_create(
+        [
+            Identification(
+                occurrence=target,
+                user_id=original.user_id,
+                taxon_id=original.taxon_id,
+                withdrawn=original.withdrawn,
+                comment=f"{original.comment}\n{note}" if original.comment else note,
+            )
+            for original, target in pairs
+        ]
+    )
+    # created_at is auto_now_add, so the original date can only be written after the insert.
+    for copy, (original, _) in zip(copies, pairs):
+        copy.created_at = original.created_at
+    Identification.objects.bulk_update(copies, ["created_at"])
+
+
+def _in_different_sessions(a: int | None, b: int | None) -> bool:
+    return a is not None and b is not None and a != b
+
+
+def relink_occurrence_chains(occurrences: Iterable[Occurrence], moved_from: dict[int, int] | None = None) -> None:
+    """Rewrite the chain links of ``occurrences`` to match the detections they now hold.
+
+    The detections of each occurrence are linked one after another in capture-time
+    order, so after a manual edit the chain agrees with the membership a reviewer
+    confirmed and the tracks export can follow it frame by frame. Within an occurrence,
+    two consecutive detections from different sessions are not linked, and only one
+    box on a capture joins the chain: the one already linked, else the lowest pk.
+    Links from these detections to detections outside them, and into them from
+    outside, are cut, since a later tracking pass would walk such a link and fold the
+    occurrences back together.
+
+    A link into another session that some other occurrence holds records one animal
+    across a session boundary (see ``split_at_session_boundaries``) and tracking never
+    walks it, so it is kept, moved to the last frame of that session's run or to the
+    first frame of the run it points into. ``moved_from`` maps a detection the edit
+    pulled out of a track to the occurrence it left: such a link stays with that
+    track rather than following the rejected frame. Costs two reads and at most two
+    writes however many occurrences and detections are involved.
+    """
+    occurrence_pks = {o.pk for o in occurrences if o.pk is not None}
+    if not occurrence_pks:
+        return
+    members = list(
+        Detection.objects.valid()
+        .filter(occurrence_id__in=occurrence_pks)
+        .order_by()
+        .values(
+            "pk",
+            "occurrence_id",
+            "source_image_id",
+            "source_image__timestamp",
+            "source_image__event_id",
+            "next_detection_id",
+            "next_detection__occurrence_id",
+            "next_detection__source_image__event_id",
+        )
+    )
+    member_pks = [m["pk"] for m in members]
+    if not member_pks:
+        return
+    inbound = list(
+        Detection.objects.filter(next_detection_id__in=member_pks)
+        .exclude(pk__in=member_pks)
+        .order_by()
+        .values("pk", "occurrence_id", "source_image__event_id", "next_detection_id")
+    )
+
+    by_pk = {m["pk"]: m for m in members}
+    current: dict[int, int | None] = {m["pk"]: m["next_detection_id"] for m in members}
+    current.update({row["pk"]: row["next_detection_id"] for row in inbound})
+    linked = {pk for pk, target in current.items() if target is not None}
+    linked |= {target for target in current.values() if target is not None}
+    desired: dict[int, int | None] = {pk: None for pk in current}
+    # Each chained member maps to the first and last frame of its session's run, and
+    # each (occurrence, session) to the first and last frame of its runs there.
+    run_head: dict[int, int] = {}
+    run_tail: dict[int, int] = {}
+    session_ends: dict[tuple[int, int | None], tuple[int, int]] = {}
+
+    by_occurrence: dict[int, list[dict]] = {}
+    for member in members:
+        by_occurrence.setdefault(member["occurrence_id"], []).append(member)
+    for occurrence_id, rows in by_occurrence.items():
+        rows.sort(key=_capture_order_key)
+        chain: list[dict] = []
+        for _, same_capture in itertools.groupby(rows, key=lambda m: m["source_image_id"]):
+            # A second box on a capture is a second animal. Keep the box the chain
+            # already runs through, so an edit elsewhere does not move the track.
+            boxes = list(same_capture)
+            chain.append(next((box for box in boxes if box["pk"] in linked), boxes[0]))
+        runs: list[list[dict]] = []
+        for row in chain:
+            if runs and not _in_different_sessions(
+                runs[-1][-1]["source_image__event_id"], row["source_image__event_id"]
+            ):
+                runs[-1].append(row)
+            else:
+                runs.append([row])
+        for run in runs:
+            for earlier, later in zip(run, run[1:]):
+                desired[earlier["pk"]] = later["pk"]
+            for row in run:
+                run_head[row["pk"]], run_tail[row["pk"]] = run[0]["pk"], run[-1]["pk"]
+            key = (occurrence_id, run[0]["source_image__event_id"])
+            session_ends[key] = (session_ends.get(key, (run[0]["pk"],))[0], run[-1]["pk"])
+
+    moved_from = moved_from or {}
+
+    def owner(pk: int, occurrence_id: int | None) -> int | None:
+        return moved_from.get(pk, occurrence_id) if pk in by_pk else occurrence_id
+
+    def endpoint(pk: int, event_id: int | None, ends: dict[int, int], end: int) -> int | None:
+        """Where a carried link attaches: ``pk`` itself unless it is in the edit."""
+        if pk not in by_pk:
+            return pk
+        if pk in moved_from and (moved_from[pk], event_id) in session_ends:
+            return session_ends[(moved_from[pk], event_id)][end]
+        return ends.get(pk)
+
+    # Carry over the links into another session that some other occurrence holds.
+    carried: list[tuple[int, int, int | None, int | None, int | None, int | None]] = [
+        (
+            m["pk"],
+            m["next_detection_id"],
+            owner(m["pk"], m["occurrence_id"]),
+            owner(m["next_detection_id"], m["next_detection__occurrence_id"]),
+            m["source_image__event_id"],
+            m["next_detection__source_image__event_id"],
+        )
+        for m in members
+        if m["next_detection_id"] is not None
+    ]
+    carried += [
+        (
+            row["pk"],
+            row["next_detection_id"],
+            row["occurrence_id"],
+            owner(row["next_detection_id"], by_pk[row["next_detection_id"]]["occurrence_id"]),
+            row["source_image__event_id"],
+            by_pk[row["next_detection_id"]]["source_image__event_id"],
+        )
+        for row in inbound
+    ]
+    taken = {target for target in desired.values() if target is not None}
+    for source, target, source_occurrence, target_occurrence, source_event, target_event in sorted(carried):
+        if source_occurrence == target_occurrence or not _in_different_sessions(source_event, target_event):
+            continue
+        new_source = endpoint(source, source_event, run_tail, -1)
+        new_target = endpoint(target, target_event, run_head, 0)
+        if new_source is None or new_target is None:
+            continue
+        if desired.get(new_source) is None and new_target not in taken:
+            desired[new_source] = new_target
+            taken.add(new_target)
+
+    changed = [pk for pk, target in desired.items() if current[pk] != target]
+    if not changed:
+        return
+    # next_detection is unique and Postgres checks it row by row, so clear every
+    # changed link before writing the new ones.
+    Detection.objects.filter(pk__in=changed).update(next_detection=None)
+    relinked = [Detection(pk=pk, next_detection_id=desired[pk]) for pk in changed if desired[pk] is not None]
+    if relinked:
+        Detection.objects.bulk_update(relinked, ["next_detection"])
+
+
+def clear_grouping_verification(*occurrences: Occurrence) -> None:
+    """Drop grouping verification from occurrences whose detection set just changed.
+
+    Clears the loaded instances as well as the rows: a caller that saves the instance
+    afterwards would otherwise write the stale confirmation straight back.
+    """
+    pks = [o.pk for o in occurrences if o.pk is not None]
+    for occurrence in occurrences:
+        occurrence.grouping_verified_at = None
+        occurrence.grouping_verified_by = None
+    if pks:
+        Occurrence.objects.filter(pk__in=pks).update(grouping_verified_at=None, grouping_verified_by=None)
+
+
+def _absorb(target: Occurrence, sources: list[Occurrence]) -> None:
+    """Move every detection and identification off ``sources`` and delete them.
+
+    Identifications move first. ``Identification.occurrence`` cascades on delete, so
+    a source removed before its identifications were reassigned would take a
+    person's work with it.
+    """
+    source_pks = [o.pk for o in sources]
+    if not source_pks:
+        return
+    Identification.objects.filter(occurrence_id__in=source_pks).update(occurrence=target)
+    Detection.objects.filter(occurrence_id__in=source_pks).update(occurrence=target)
+    Occurrence.objects.filter(pk__in=source_pks).delete()
+
+
+def _refuse_two_boxes_on_one_capture(target: Occurrence, incoming_capture_ids: Iterable[int]) -> None:
+    """Refuse an edit that would put two boxes from one capture into ``target``.
+
+    One animal appears at most once per capture, so a second box on a capture is a
+    second individual. Only captures the edit brings in are checked, so a track that
+    already holds such a pair can still be edited.
+    """
+    counts = Counter(incoming_capture_ids)
+    if not counts:
+        return
+    covered = set(
+        Detection.objects.valid()
+        .filter(occurrence_id=target.pk, source_image_id__in=list(counts))
+        .values_list("source_image_id", flat=True)
+    )
+    clashes = covered | {capture_id for capture_id, n in counts.items() if n > 1}
+    if clashes:
+        # Reviewers read this in the merge and extend dialogs, so name capture times, not ids.
+        timestamps = (
+            SourceImage.objects.filter(pk__in=clashes).order_by("timestamp", "pk").values_list("timestamp", flat=True)
+        )
+        times = ", ".join(_time_of_day(timestamp) for timestamp in timestamps)
+        captures = "the capture" if len(clashes) == 1 else "the captures"
+        raise TrackEditError(
+            f"This would put two detections from {captures} at {times} into one occurrence. "
+            "One animal appears once per capture, so these are different individuals."
+        )
+
+
+def refuse_edit_outside_session(
+    target: Occurrence, members: Iterable[tuple[int, int | None, int | None]] = (), noun: str = "Occurrence(s)"
+) -> None:
+    """Refuse a track edit unless ``target`` has a session and every member shares it and its project.
+
+    ``members`` are ``(pk, project_id, event_id)`` of what the edit brings in. A capture that was
+    never grouped has no session, so it matches nothing, and without the project check two
+    session-less occurrences from different projects would compare equal.
+    """
+    if target.event_id is None:
+        raise TrackEditError(
+            f"Occurrence {target.pk} has no session. Group its captures into sessions before editing its track."
+        )
+    outside = sorted(
+        pk for pk, project_id, event_id in members if event_id != target.event_id or project_id != target.project_id
+    )
+    if outside:
+        raise TrackEditError(
+            f"{noun} {outside} are not in the session and project of occurrence {target.pk}. "
+            "An occurrence cannot span sessions or projects."
+        )
+
+
+def _time_of_day(timestamp: datetime.datetime | None) -> str:
+    """A capture time as a reviewer reads it on the session page, e.g. 10:48:23 PM."""
+    if timestamp is None:
+        return "an unknown time"
+    return timestamp.strftime("%I:%M:%S %p").lstrip("0")
+
+
+@transaction.atomic
+def merge_occurrences(target: Occurrence, sources: Iterable[Occurrence]) -> Occurrence:
+    """Fold ``sources`` into ``target``: one animal that tracking recorded as several.
+
+    Every detection and identification moves to ``target`` and the emptied sources
+    are deleted. Sources must belong to the target's session and project, since an
+    occurrence cannot span two nights.
+    """
+    sources = [o for o in sources if o.pk != target.pk]
+    if not sources:
+        raise TrackEditError("Nothing to merge: no occurrence other than the target was given.")
+    _lock_for_edit(target, *sources)
+
+    refuse_edit_outside_session(target, ((o.pk, o.project_id, o.event_id) for o in sources))
+    _refuse_two_boxes_on_one_capture(
+        target,
+        Detection.objects.valid()
+        .filter(occurrence_id__in=[o.pk for o in sources])
+        .values_list("source_image_id", flat=True),
+    )
+
+    _absorb(target, sources)
+    relink_occurrence_chains([target])
+    clear_grouping_verification(target)
+    target.save()
+    refresh_track_stats(target)
+    update_calculated_fields_for_sessions_and_stations([target.event_id])
+    return target
+
+
+def _fill_timestamps_from_captures(detections: Iterable[Detection]) -> None:
+    """Give every detection the timestamp of its capture, as ``Detection.save`` does.
+
+    A detection that was never grouped can reach a track without one, and an undated
+    detection sorts outside its own track and is skipped by the track statistics.
+    Written in a single query so the cost does not follow how many moved.
+    """
+    undated = [d for d in detections if d.timestamp is None]
+    if not undated:
+        return
+    for detection in undated:
+        detection.timestamp = detection.source_image.timestamp
+    Detection.objects.bulk_update(undated, ["timestamp"])
+
+
+@transaction.atomic
+def add_detections(target: Occurrence, detections: Iterable[Detection]) -> Occurrence:
+    """Move individual detections into ``target``.
+
+    Use when a frame belongs to this animal but landed on its own, on the wrong
+    occurrence, or on no occurrence at all, which is how a detector-only project
+    leaves most of its boxes. A detection with no occurrence simply moves in; there
+    is no donor to absorb. Any occurrence left with no detections is absorbed rather
+    than deleted outright, so identifications on it survive.
+    """
+    detections = list(detections)
+    _lock_for_edit(target, detections=detections)
+    detections = [d for d in detections if d.occurrence_id != target.pk]
+    if not detections:
+        raise TrackEditError("Nothing to add: every detection given is already in this occurrence.")
+
+    donor_pks = {d.occurrence_id for d in detections if d.occurrence_id}
+    refuse_edit_outside_session(
+        target, ((d.pk, d.source_image.project_id, d.source_image.event_id) for d in detections), "Detection(s)"
+    )
+    _refuse_two_boxes_on_one_capture(target, [d.source_image_id for d in detections])
+
+    donors = list(Occurrence.objects.filter(pk__in=donor_pks))
+    Detection.objects.filter(pk__in=[d.pk for d in detections]).update(occurrence=target)
+    _fill_timestamps_from_captures(detections)
+
+    emptied = [o for o in donors if not o.detections.exists()]
+    _absorb(target, emptied)
+
+    remaining = [o for o in donors if o.pk not in {e.pk for e in emptied}]
+    relink_occurrence_chains(
+        [target, *remaining],
+        moved_from={d.pk: d.occurrence_id for d in detections if d.occurrence_id in {o.pk for o in remaining}},
+    )
+    for donor in remaining:
+        donor.save()
+
+    clear_grouping_verification(target, *remaining)
+    target.save()
+    refresh_track_stats(target, *remaining)
+    update_calculated_fields_for_sessions_and_stations([target.event_id, *(donor.event_id for donor in donors)])
+    return target
+
+
+@transaction.atomic
+def verify_grouping(occurrence: Occurrence, user: User) -> Occurrence:
+    """Record that a person confirmed this occurrence holds the right detections.
+
+    This is the label the tracking methods are scored against, so it is deliberately
+    an explicit act — no operation in this module sets it as a side effect.
+    """
+    _lock_for_edit(occurrence)
+    occurrence.grouping_verified_at = timezone.now()
+    occurrence.grouping_verified_by = user
+    occurrence.save(update_fields=["grouping_verified_at", "grouping_verified_by"])
+    return occurrence
+
+
+@transaction.atomic
+def unverify_grouping(occurrence: Occurrence) -> Occurrence:
+    """Withdraw a previous confirmation, leaving the detections untouched."""
+    _lock_for_edit(occurrence)
+    occurrence.grouping_verified_at = None
+    occurrence.grouping_verified_by = None
+    occurrence.save(update_fields=["grouping_verified_at", "grouping_verified_by"])
+    return occurrence
diff --git a/ami/main/tasks.py b/ami/main/tasks.py
index 16f927a3f..aa34990e5 100644
--- a/ami/main/tasks.py
+++ b/ami/main/tasks.py
@@ -23,3 +23,12 @@ def refresh_project_cached_counts(project_id: int) -> None:
 
     logger.info(f"Refreshing cached counts for project {project.pk} ({project.name})")
     project.update_related_calculated_fields()
+
+
+@celery_app.task(ignore_result=True)
+def refresh_deployment_cached_counts(deployment_ids: list[int]) -> None:
+    """Refresh the cached counts of these stations after an edit changed their occurrences."""
+    from ami.main.models import Deployment
+
+    for deployment in Deployment.objects.filter(pk__in=deployment_ids):
+        deployment.update_calculated_fields(save=True)
diff --git a/ami/main/tests.py b/ami/main/tests.py
index aab6d943d..ef3ffb616 100644
--- a/ami/main/tests.py
+++ b/ami/main/tests.py
@@ -1,7 +1,10 @@
 import copy
 import datetime
+import itertools
 import logging
+import re
 import typing
+from contextlib import contextmanager
 from io import BytesIO
 from unittest import mock
 
@@ -40,11 +43,31 @@
     TaxaList,
     Taxon,
     TaxonRank,
+    get_media_url,
     group_images_into_events,
 )
+from ami.main.models_future.tracks import (
+    SessionBusy,
+    TrackEditError,
+    add_detections,
+    detach_detection,
+    merge_occurrences,
+    relink_occurrence_chains,
+    split_track,
+    verify_grouping,
+)
+from ami.ml.models.algorithm import Algorithm
 from ami.ml.models.pipeline import Pipeline
 from ami.ml.models.processing_service import ProcessingService
 from ami.ml.models.project_pipeline_config import ProjectPipelineConfig
+from ami.ml.post_processing.tracking_task import (
+    TrackingConfig,
+    box_ratio,
+    image_diagonal,
+    iou,
+    pair_detections,
+    total_cost,
+)
 from ami.tests.fixtures.main import (
     create_captures,
     create_captures_from_files,
@@ -67,6 +90,24 @@
 logger = logging.getLogger(__name__)
 
 
+@contextmanager
+def cachalot_disabled():
+    """Measure queries with cachalot off, and turn it back on even when the block raises.
+
+    ``cachalot.api.cachalot_disabled`` restores its thread-local flag only on a clean exit,
+    so one failing query-count assertion would leave every later test in the process
+    uncached and failing on its own count.
+    """
+    from cachalot.api import cachalot_disabled as upstream
+
+    upstream_block = upstream()
+    upstream_block.__enter__()
+    try:
+        yield
+    finally:
+        upstream_block.__exit__(None, None, None)
+
+
 class TestProjectSetup(TestCase):
     def test_project_creation(self):
         project = Project.objects.create(name="New Project with Defaults", create_defaults=True)
@@ -815,6 +856,84 @@ def test_thumbnails_check_does_not_fetch_project_per_capture(self):
         )
 
 
+class TestCaptureNeighboursWithDetections(APITestCase):
+    """The capture detail names the nearest capture on each side that holds a real box.
+
+    Motion-triggered stations shoot bursts seconds apart, so stepping minute by minute
+    skips frames of the same animal. The walk must go one capture at a time.
+    """
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=1)
+        first = SourceImage.objects.get(deployment=self.deployment)
+        self.event = first.event
+        self.burst_start = first.timestamp + datetime.timedelta(minutes=1)
+        self.client.force_authenticate(User.objects.create_superuser(email="neighbours@insectai.org"))
+
+    def _capture(self, seconds: int, bbox: list[int] | None = None, detected: bool = True) -> SourceImage:
+        """A capture `seconds` into the burst, with one detection unless `detected` is False.
+
+        A `bbox` of None makes that detection a null marker: the detector ran and found nothing.
+        """
+        timestamp = self.burst_start + datetime.timedelta(seconds=seconds)
+        path = f"test/burst-{SourceImage.objects.filter(event=self.event).count()}.jpg"
+        capture = SourceImage.objects.create(
+            deployment=self.deployment, event=self.event, timestamp=timestamp, path=path
+        )
+        if detected:
+            Detection.objects.create(source_image=capture, timestamp=timestamp, bbox=bbox)
+        return capture
+
+    def _get(self, capture: SourceImage) -> dict:
+        response = self.client.get(f"/api/v2/captures/{capture.pk}/?project_id={self.project.pk}")
+        self.assertEqual(response.status_code, 200)
+        return response.json()
+
+    def test_neighbours_step_through_a_burst_one_capture_at_a_time(self):
+        box = [10, 10, 40, 40]
+        first = self._capture(0, box)
+        empty = self._capture(2, detected=False)
+        null_only = self._capture(4, bbox=None)
+        # Two captures sharing a timestamp are still visited in turn, lower id first.
+        tied_low = self._capture(6, box)
+        tied_high = self._capture(6, box)
+        trailing = self._capture(8, detected=False)
+
+        expected = {
+            first: (tied_low, None),
+            empty: (tied_low, first),
+            null_only: (tied_low, first),
+            tied_low: (tied_high, first),
+            tied_high: (None, tied_low),
+            trailing: (None, tied_high),
+        }
+        for capture, (next_capture, prev_capture) in expected.items():
+            with self.subTest(capture=capture.path):
+                data = self._get(capture)
+                self.assertEqual(
+                    data["event_next_capture_with_detections_id"], next_capture.pk if next_capture else None
+                )
+                self.assertEqual(
+                    data["event_prev_capture_with_detections_id"], prev_capture.pk if prev_capture else None
+                )
+
+    def test_detail_query_count_does_not_follow_the_session_size(self):
+        """The neighbours come from subqueries in the detail query, not from a query per capture."""
+        capture = self._capture(0, [10, 10, 40, 40])
+
+        def count_queries() -> int:
+            with cachalot_disabled(), CaptureQueriesContext(connection) as context:
+                self._get(capture)
+            return len(context.captured_queries)
+
+        baseline = count_queries()
+        for seconds in range(2, 22, 2):
+            self._capture(seconds, [10, 10, 40, 40])
+        self.assertEqual(count_queries(), baseline)
+
+
 class TestImageGrouping(TestCase):
     def setUp(self) -> None:
         print(f"Currently active database: {connection.settings_dict}")
@@ -1238,6 +1357,284 @@ def test_setting_image_dimensions(self):
                 assert (capture.width == image_width) and (capture.height == image_height)
 
 
+class TestRegroupSplitsTracks(TestCase):
+    """Regrouping never leaves one occurrence spanning two sessions.
+
+    The captures are two bursts three hours apart: one session under a 6-hour gap, two
+    under a 2-hour gap. A track built across all of them is what an earlier grouping
+    leaves behind when a later regroup draws a boundary through it.
+    """
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_taxa(project=self.project)
+        self.taxon, self.other_taxon = list(Taxon.objects.filter(projects=self.project).order_by("pk")[:2])
+        self.user = User.objects.create_user(email="regroup-identifier@insectai.org")  # type: ignore[attr-defined]
+        start = datetime.datetime(2024, 6, 1, 22, 0)
+        self.captures = [
+            SourceImage.objects.create(
+                deployment=self.deployment,
+                timestamp=start + datetime.timedelta(minutes=minutes),
+                path=f"test/regroup-split-{i}.jpg",
+                width=640,
+                height=480,
+            )
+            for i, minutes in enumerate([0, 1, 2, 180, 181, 182])
+        ]
+
+    def _group(self, gap_hours: int, job: Job | None = None) -> list[Event]:
+        group_images_into_events(
+            self.deployment,
+            max_time_gap=datetime.timedelta(hours=gap_hours),
+            job=job,
+            stage_key="regroup" if job else None,
+        )
+        for capture in self.captures:
+            capture.refresh_from_db()
+        return list(Event.objects.filter(deployment=self.deployment).order_by("start"))
+
+    def _make_track(self, captures: list[SourceImage]) -> tuple[Occurrence, list[Detection]]:
+        occurrence = Occurrence.objects.create(
+            event=captures[0].event, deployment=self.deployment, project=self.project
+        )
+        detections = []
+        for capture in captures:
+            detection = Detection.objects.create(
+                source_image=capture, timestamp=capture.timestamp, bbox=[10, 10, 40, 40], occurrence=occurrence
+            )
+            detection.classifications.create(taxon=self.taxon, score=0.9, timestamp=capture.timestamp)
+            detections.append(detection)
+        for earlier, later in zip(detections, detections[1:]):
+            earlier.next_detection = later
+            earlier.save(update_fields=["next_detection"])
+        occurrence.save()
+        return occurrence, detections
+
+    def _split_one_track(self) -> tuple[Occurrence, Occurrence, list[Detection], list[Event]]:
+        self._group(gap_hours=6)
+        occurrence, detections = self._make_track(self.captures)
+        events = self._group(gap_hours=2)
+        self.assertEqual(len(events), 2)
+        piece = Occurrence.objects.exclude(pk=occurrence.pk).get(deployment=self.deployment)
+        occurrence.refresh_from_db()
+        return occurrence, piece, detections, events
+
+    def _detection_ids(self, occurrence: Occurrence) -> list[int]:
+        return list(occurrence.detections.order_by("timestamp").values_list("pk", flat=True))
+
+    def test_a_track_across_a_new_boundary_is_split_into_one_occurrence_per_session(self):
+        occurrence, piece, detections, (first, second) = self._split_one_track()
+
+        self.assertEqual(self._detection_ids(occurrence), [d.pk for d in detections[:3]])
+        self.assertEqual(self._detection_ids(piece), [d.pk for d in detections[3:]])
+        self.assertEqual(occurrence.event_id, first.pk)
+        self.assertEqual(piece.event_id, second.pk)
+        self.assertEqual(piece.determination_id, self.taxon.pk)
+        self.assertEqual(first.occurrences_count, 1)
+        self.assertEqual(second.occurrences_count, 1)
+        self.assertEqual(piece.track_motion, 0.0)
+
+    def test_the_link_between_the_pieces_is_kept(self):
+        _, _, detections, _ = self._split_one_track()
+
+        boundary = Detection.objects.get(pk=detections[2].pk)
+        self.assertEqual(boundary.next_detection_id, detections[3].pk, "The pieces still record one animal")
+
+    def test_editing_a_piece_keeps_the_link_into_the_other_session(self):
+        from ami.main.models_future.tracks import merge_occurrences
+
+        occurrence, _, detections, (first, _) = self._split_one_track()
+        extra_capture = SourceImage.objects.create(
+            deployment=self.deployment,
+            event=first,
+            timestamp=self.captures[2].timestamp + datetime.timedelta(seconds=30),
+            path="test/regroup-split-extra.jpg",
+            width=640,
+            height=480,
+        )
+        loose = Occurrence.objects.create(event=first, deployment=self.deployment, project=self.project)
+        extra = Detection.objects.create(
+            source_image=extra_capture, timestamp=extra_capture.timestamp, bbox=[10, 10, 40, 40], occurrence=loose
+        )
+
+        merge_occurrences(occurrence, [loose])
+
+        self.assertEqual(Detection.objects.get(pk=detections[2].pk).next_detection_id, extra.pk)
+        self.assertEqual(
+            Detection.objects.get(pk=extra.pk).next_detection_id,
+            detections[3].pk,
+            "A merge into one piece keeps its link into the next session, now from the piece's last frame",
+        )
+
+    def test_detaching_the_last_frame_of_the_earlier_piece_hands_its_link_to_the_new_last_frame(self):
+        from ami.main.models_future.tracks import detach_detection
+
+        occurrence, _, detections, _ = self._split_one_track()
+
+        detach_detection(occurrence, detections[2])
+
+        self.assertIsNone(Detection.objects.get(pk=detections[2].pk).next_detection_id, "The rejected frame")
+        self.assertEqual(Detection.objects.get(pk=detections[1].pk).next_detection_id, detections[3].pk)
+
+    def test_detaching_the_first_frame_of_the_later_piece_relinks_to_its_new_first_frame(self):
+        from ami.main.models_future.tracks import detach_detection
+
+        _, piece, detections, _ = self._split_one_track()
+
+        detach_detection(piece, detections[3])
+
+        self.assertIsNone(Detection.objects.get(pk=detections[3].pk).next_detection_id)
+        self.assertEqual(Detection.objects.get(pk=detections[2].pk).next_detection_id, detections[4].pk)
+
+    def test_moving_the_last_frame_of_the_earlier_piece_elsewhere_leaves_the_link_with_that_piece(self):
+        from ami.main.models_future.tracks import add_detections
+
+        _, _, detections, (first, _) = self._split_one_track()
+        other_capture = SourceImage.objects.create(
+            deployment=self.deployment,
+            event=first,
+            timestamp=self.captures[2].timestamp + datetime.timedelta(seconds=30),
+            path="test/regroup-split-other.jpg",
+            width=640,
+            height=480,
+        )
+        other = Occurrence.objects.create(event=first, deployment=self.deployment, project=self.project)
+        Detection.objects.create(
+            source_image=other_capture, timestamp=other_capture.timestamp, bbox=[10, 10, 40, 40], occurrence=other
+        )
+
+        add_detections(other, [Detection.objects.get(pk=detections[2].pk)])
+
+        self.assertEqual(Detection.objects.get(pk=detections[1].pk).next_detection_id, detections[3].pk)
+
+    def test_merging_sessions_leaves_tracks_untouched(self):
+        self._group(gap_hours=2)
+        early, early_detections = self._make_track(self.captures[:3])
+        late, late_detections = self._make_track(self.captures[3:])
+
+        (merged,) = self._group(gap_hours=6)
+
+        self.assertEqual(Occurrence.objects.filter(deployment=self.deployment).count(), 2)
+        self.assertEqual(self._detection_ids(early), [d.pk for d in early_detections])
+        self.assertEqual(self._detection_ids(late), [d.pk for d in late_detections])
+        self.assertEqual(
+            set(Occurrence.objects.filter(deployment=self.deployment).values_list("event_id", flat=True)),
+            {merged.pk},
+        )
+
+    def test_every_piece_keeps_the_grouping_confirmation(self):
+        self._group(gap_hours=6)
+        occurrence, _ = self._make_track(self.captures)
+        verified_at = timezone.now()
+        Occurrence.objects.filter(pk=occurrence.pk).update(
+            grouping_verified_at=verified_at, grouping_verified_by=self.user
+        )
+
+        self._group(gap_hours=2)
+
+        pieces = Occurrence.objects.filter(deployment=self.deployment)
+        self.assertEqual(pieces.count(), 2)
+        for piece in pieces:
+            self.assertEqual(piece.grouping_verified_at, verified_at)
+            self.assertEqual(piece.grouping_verified_by_id, self.user.pk)
+
+    def test_identifications_are_copied_to_every_piece(self):
+        self._group(gap_hours=6)
+        occurrence, _ = self._make_track(self.captures)
+        superseded = Identification.objects.create(occurrence=occurrence, user=self.user, taxon=self.taxon)
+        current = Identification.objects.create(
+            occurrence=occurrence, user=self.user, taxon=self.other_taxon, comment="Wing pattern checked."
+        )
+
+        self._group(gap_hours=2)
+
+        occurrence.refresh_from_db()
+        piece = Occurrence.objects.exclude(pk=occurrence.pk).get(deployment=self.deployment)
+        self.assertEqual(set(occurrence.identifications.values_list("pk", flat=True)), {superseded.pk, current.pk})
+        note = f"Copied from occurrence {occurrence.pk} when regrouping split it at a session boundary."
+        copies = {(i.taxon_id, i.user_id, i.withdrawn, i.created_at, i.comment) for i in piece.identifications.all()}
+        superseded.refresh_from_db()
+        self.assertEqual(
+            copies,
+            {
+                (self.taxon.pk, self.user.pk, True, superseded.created_at, note),
+                (self.other_taxon.pk, self.user.pk, False, current.created_at, f"Wing pattern checked.\n{note}"),
+            },
+        )
+        self.assertFalse(
+            piece.identifications.filter(
+                models.Q(agreed_with_identification__isnull=False) | models.Q(agreed_with_prediction__isnull=False)
+            ).exists()
+        )
+        self.assertEqual(occurrence.determination_id, self.other_taxon.pk)
+        self.assertEqual(piece.determination_id, self.other_taxon.pk)
+
+    def test_retracking_both_sessions_does_not_merge_the_pieces_again(self):
+        from ami.ml.post_processing.tracking_task import assign_occurrences_by_tracking_images
+
+        occurrence, piece, detections, events = self._split_one_track()
+
+        for event in events:
+            assign_occurrences_by_tracking_images(
+                event=event,
+                logger=logging.getLogger(__name__),
+                algorithm=None,
+                config=TrackingConfig(event_ids=[event.pk], require_features=False),
+            )
+
+        self.assertEqual(Occurrence.objects.filter(deployment=self.deployment).count(), 2)
+        self.assertEqual(self._detection_ids(occurrence), [d.pk for d in detections[:3]])
+        self.assertEqual(self._detection_ids(piece), [d.pk for d in detections[3:]])
+        self.assertEqual(Detection.objects.get(pk=detections[2].pk).next_detection_id, detections[3].pk)
+
+    def test_the_later_session_is_not_fresh_for_tracking(self):
+        from ami.ml.post_processing.tracking_task import event_is_fresh
+
+        _, _, _, (_, second) = self._split_one_track()
+
+        fresh, _ = event_is_fresh(second)
+        self.assertFalse(fresh)
+
+    def test_a_session_holding_part_of_a_track_filed_under_another_session_is_not_fresh(self):
+        from ami.ml.post_processing.tracking_task import event_is_fresh
+
+        _, second = self._group(gap_hours=2)
+        self._make_track(self.captures)  # Filed under the first session, reaching into the second.
+
+        fresh, _ = event_is_fresh(second)
+        self.assertFalse(fresh)
+
+    def test_regroup_reports_the_split_count_and_a_second_regroup_splits_nothing(self):
+        self._group(gap_hours=6)
+        self._make_track(self.captures)
+        job = Job.objects.create(
+            name="Regroup", job_type_key="regroup_events", project=self.project, deployment=self.deployment
+        )
+        job.progress.add_stage("Regroup", key="regroup")
+        job.save()
+
+        self._group(gap_hours=2, job=job)
+        job.refresh_from_db()
+        self.assertEqual(job.progress.get_stage_param("regroup", "occurrences_split_at_a_session_boundary").value, 1)
+
+        self._group(gap_hours=2, job=job)
+        job.refresh_from_db()
+        self.assertEqual(job.progress.get_stage_param("regroup", "occurrences_split_at_a_session_boundary").value, 0)
+        self.assertEqual(Occurrence.objects.filter(deployment=self.deployment).count(), 2)
+
+    def test_a_manual_split_gives_the_tail_the_session_of_its_detections(self):
+        from ami.main.models_future.tracks import split_track
+
+        first, second = self._group(gap_hours=2)
+        # A track left spanning both sessions, as tracking produced it before this regroup rule.
+        occurrence, detections = self._make_track(self.captures)
+
+        tail = split_track(occurrence, detections[3])
+
+        self.assertEqual(tail.event_id, second.pk)
+        self.assertEqual(Occurrence.objects.get(pk=occurrence.pk).event_id, first.pk)
+
+
 # This test is disabled because it requires certain data to be present in the database
 # and data in a configured S3 bucket. Will require Minio or something like it to be running.
 # from unittest import TestCase as UnitTestCase
@@ -3284,6 +3681,41 @@ def test_user_permissions_reflected_in_job_detail(self):
         self.assertNotIn("run", response.data.get("user_permissions", []))
 
 
+class TestRunTrackingProjectPermission(APITestCase):
+    """The project detail reports ``run_tracking`` only when a tracking job could be created and run."""
+
+    def setUp(self):
+        super().setUp()
+        self.project = Project.objects.create(name="Tracking Permission Project")
+        self.ml_data_manager = User.objects.create_user(email="mldm@insectai.org")
+        self.basic_member = User.objects.create_user(email="basic@insectai.org")
+        self.superuser = User.objects.create_superuser(email="super@insectai.org", password="password123")
+        MLDataManager.assign_user(self.ml_data_manager, self.project)
+        BasicMember.assign_user(self.basic_member, self.project)
+
+    def _set_tracking(self, enabled: bool):
+        self.project.feature_flags.tracking = enabled
+        self.project.save(update_fields=["feature_flags"])
+
+    def _may_run_tracking(self, user) -> bool:
+        self.client.force_authenticate(user)
+        response = self.client.get(f"/api/v2/projects/{self.project.pk}/")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        return Project.Permissions.RUN_TRACKING in response.data["user_permissions"]
+
+    def test_flag_on(self):
+        self._set_tracking(True)
+        self.assertTrue(self._may_run_tracking(self.ml_data_manager))
+        self.assertTrue(self._may_run_tracking(self.superuser))
+        self.assertFalse(self._may_run_tracking(self.basic_member))
+        self.assertFalse(self._may_run_tracking(None))
+
+    def test_flag_off(self):
+        self._set_tracking(False)
+        for user in (self.ml_data_manager, self.superuser, self.basic_member, None):
+            self.assertFalse(self._may_run_tracking(user))
+
+
 class TestRunSingleImageJobPermission(APITestCase):
     def setUp(self):
         super().setUp()
@@ -3351,12 +3783,15 @@ def test_user_can_run_single_image_job_and_perm_is_reflected(self):
         )
 
         # Should not be able to run job now
+        jobs_before = Job.objects.filter(project=self.project).count()
         response = self.client.post(run_url, payload, format="json")
         self.assertEqual(
             response.status_code,
             403,
             f"User should NOT be able to run single image job after permission removal, got {response.status_code}",
         )
+        # The refusal comes before the save, so no job is left behind.
+        self.assertEqual(Job.objects.filter(project=self.project).count(), jobs_before)
 
 
 class TestMLDataManagerCanRunBatchMLJob(APITestCase):
@@ -5951,6 +6386,71 @@ def test_source_image_cached_counts_refresh_on_threshold_change(self):
             )
 
 
+class TestOccurrenceDeterminationScoreRefresh(TestCase):
+    """Regression test for `update_occurrence_determination`.
+
+    Tracking can fold a new detection into an existing occurrence whose top
+    species classification scores higher than the keeper's. The taxon stays the
+    same across the chain, but the keeper's `determination_score` should
+    refresh to reflect the strongest evidence available — not stay pinned to
+    the score from the first detection.
+    """
+
+    def setUp(self) -> None:
+        from ami.ml.models import Algorithm
+
+        self.project, self.deployment = setup_test_project()
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=2)
+        create_taxa(project=self.project)
+        self.taxon = Taxon.objects.filter(projects=self.project).first()
+        self.algorithm = Algorithm.objects.create(name="Test Species Classifier", version=1)
+
+    def _make_detection_with_classification(self, source_image: SourceImage, score: float) -> Detection:
+        occurrence = Occurrence.objects.create(
+            project=self.project,
+            event=source_image.event,
+            deployment=self.deployment,
+            determination=self.taxon,
+            determination_score=score,
+        )
+        detection = Detection.objects.create(
+            source_image=source_image,
+            occurrence=occurrence,
+            timestamp=source_image.timestamp,
+        )
+        Classification.objects.create(
+            detection=detection,
+            taxon=self.taxon,
+            algorithm=self.algorithm,
+            score=score,
+            terminal=True,
+            timestamp=source_image.timestamp,
+        )
+        return detection
+
+    def test_score_refreshes_when_taxon_unchanged(self) -> None:
+        """When best_prediction has the same taxon but a higher score, the
+        keeper's determination_score must update on save()."""
+        captures = list(self.deployment.captures.order_by("timestamp")[:2])
+        keeper_det = self._make_detection_with_classification(captures[0], score=0.20)
+        absorbed_det = self._make_detection_with_classification(captures[1], score=0.55)
+        keeper = keeper_det.occurrence
+        absorbed = absorbed_det.occurrence
+        assert keeper is not None and absorbed is not None
+
+        # Simulate tracking merge: reassign absorbed detection to keeper.
+        absorbed_det.occurrence = keeper
+        absorbed_det.save()
+        Occurrence.objects.filter(pk=absorbed.pk).delete()
+
+        # Keeper.save() should pick up the higher score from the merged-in detection.
+        keeper.save()
+        keeper.refresh_from_db()
+
+        self.assertEqual(keeper.determination, self.taxon)
+        self.assertAlmostEqual(keeper.determination_score, 0.55, places=4)
+
+
 class TestLcaRankBetween(TestCase):
     """Pure-Python LCA over (taxon_id, rank, parents_json) tuples.
 
@@ -8414,3 +8914,2493 @@ def test_identifications_browsable_page(self):
         html = self._get_html("/api/v2/identifications/")
         self._assert_number_input(html, "occurrence")
         self._assert_number_input(html, "taxon")
+
+
+def enable_tracking(project: Project) -> None:
+    """Opt a fixture project into tracking, which the track-editing endpoints require."""
+    project.feature_flags.tracking = True
+    project.save(update_fields=["feature_flags"])
+
+
+class TrackFixtureTestCase(APITestCase):
+    """One four-frame track in a tracking-enabled project, with a curator and a reader."""
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        enable_tracking(self.project)
+        create_taxa(project=self.project)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=4, interval_minutes=1)
+
+        self.captures = list(SourceImage.objects.filter(deployment=self.deployment).order_by("timestamp"))
+        assert len(self.captures) >= 4, "Fixture must provide four consecutive captures"
+        self.event = self.captures[0].event
+
+        self.curator = User.objects.create_user(email="curator@insectai.org")  # type: ignore[attr-defined]
+        self.reader = User.objects.create_user(email="reader@insectai.org")  # type: ignore[attr-defined]
+        MLDataManager.assign_user(self.curator, self.project)
+        BasicMember.assign_user(self.reader, self.project)
+
+        taxon = Taxon.objects.filter(projects=self.project).first()
+        assert taxon is not None, "Fixture must provide a taxon to determine occurrences with"
+        self.taxon = taxon
+
+        self.occurrence, self.detections = self._make_track(len(self.captures))
+        return super().setUp()
+
+    def _make_captures_after(self, count: int) -> list[SourceImage]:
+        """Captures later in the same session, for a second track that shares no capture with the first."""
+        last = self.captures[-1]
+        return [
+            SourceImage.objects.create(
+                deployment=self.deployment,
+                event=self.event,
+                timestamp=last.timestamp + datetime.timedelta(minutes=i + 1),
+                path=f"test/after-{last.pk}-{i}.jpg",
+            )
+            for i in range(count)
+        ]
+
+    def _make_track(
+        self, length: int, score: float | None = 0.9, captures: list[SourceImage] | None = None
+    ) -> tuple[Occurrence, list[Detection]]:
+        """One occurrence holding `length` detections, chained in capture order.
+
+        Each detection carries a classification at `score`, which settles the
+        occurrence's determination. A `score` of None leaves them unclassified, so the
+        occurrence has no determination: the shape every occurrence has on a project
+        where only a detector ran.
+        """
+        occurrence = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+        detections = []
+        for capture in (captures or self.captures)[:length]:
+            detection = Detection.objects.create(
+                source_image=capture,
+                timestamp=capture.timestamp,
+                bbox=[10, 10, 40, 40],
+                occurrence=occurrence,
+            )
+            if score is not None:
+                detection.classifications.create(taxon=self.taxon, score=score, timestamp=capture.timestamp)
+            detections.append(detection)
+        for earlier, later in zip(detections, detections[1:]):
+            earlier.next_detection = later
+            earlier.save(update_fields=["next_detection"])
+        occurrence.save()
+        return occurrence, detections
+
+    def post(self, action: str, detection: Detection, user: User | None = None):
+        if user is not None:
+            self.client.force_authenticate(user=user)
+        return self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/{action}/",
+            {"detection_id": detection.pk},
+            format="json",
+        )
+
+
+class TrackEditTestCase(TrackFixtureTestCase):
+    """Correcting a track that tracking got wrong.
+
+    Tracking prefers to leave one animal as two occurrences over merging two
+    animals into one, because a wrong merge destroys a record nothing downstream
+    recovers. These endpoints are the repair for the merges it still makes, so
+    what they must protect is that a repair never loses a detection and never
+    leaves the surviving track broken in the middle.
+    """
+
+    def test_an_edit_refused_because_a_run_holds_the_session_is_a_conflict(self):
+        """A reviewer blocked by a tracking run gets 409 with the reason, not a 400 or 500."""
+        busy = SessionBusy("Tracking is running on this session; try again when it finishes.")
+        self.client.force_authenticate(user=self.curator)
+        with mock.patch("ami.main.api.views.split_track", side_effect=busy):
+            split = self.post("split-track", self.detections[2])
+        with mock.patch("ami.main.api.views.verify_grouping", side_effect=busy):
+            verify = self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/verify-grouping/")
+        with mock.patch("ami.main.api.views.unverify_grouping", side_effect=TrackEditError("gone")):
+            unverify = self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/unverify-grouping/")
+
+        self.assertEqual((split.status_code, verify.status_code, unverify.status_code), (409, 409, 400))
+        self.assertEqual(verify.data["detail"], str(busy))
+
+    def test_split_moves_the_tail_into_a_new_occurrence(self):
+        response = self.post("split-track", self.detections[2], user=self.curator)
+        self.assertEqual(response.status_code, 200, response.data)
+
+        new_occurrence = Occurrence.objects.get(pk=response.data["new_occurrence_id"])
+        self.assertEqual(
+            [d.pk for d in self.detections[:2]],
+            list(self.occurrence.detections.order_by("timestamp").values_list("pk", flat=True)),
+        )
+        self.assertEqual(
+            [d.pk for d in self.detections[2:]],
+            list(new_occurrence.detections.order_by("timestamp").values_list("pk", flat=True)),
+        )
+
+    def test_split_cuts_the_link_across_the_new_boundary(self):
+        self.post("split-track", self.detections[2], user=self.curator)
+
+        boundary = Detection.objects.get(pk=self.detections[1].pk)
+        self.assertIsNone(boundary.next_detection_id, "The two tracks must stop referring to each other")
+        still_linked = Detection.objects.get(pk=self.detections[2].pk)
+        self.assertEqual(still_linked.next_detection_id, self.detections[3].pk, "The tail stays one track")
+
+    def test_split_at_the_first_detection_is_rejected(self):
+        response = self.post("split-track", self.detections[0], user=self.curator)
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(Occurrence.objects.filter(event=self.event).count(), 1)
+
+    def test_removing_a_middle_detection_stitches_the_rest_together(self):
+        response = self.post("remove-detection", self.detections[1], user=self.curator)
+        self.assertEqual(response.status_code, 200, response.data)
+
+        self.assertEqual(
+            [self.detections[0].pk, self.detections[2].pk, self.detections[3].pk],
+            list(self.occurrence.detections.order_by("timestamp").values_list("pk", flat=True)),
+        )
+        stitched = Detection.objects.get(pk=self.detections[0].pk)
+        self.assertEqual(
+            stitched.next_detection_id,
+            self.detections[2].pk,
+            "Removing a frame from the middle must not also split what remains",
+        )
+        removed = Detection.objects.get(pk=self.detections[1].pk)
+        self.assertIsNone(removed.next_detection_id)
+        self.assertEqual(removed.occurrence_id, response.data["new_occurrence_id"])
+
+    def test_a_detection_from_another_occurrence_is_rejected(self):
+        other_occurrence, other_detections = self._make_track(2)
+        response = self.post("remove-detection", other_detections[0], user=self.curator)
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(other_detections[0].occurrence_id, other_occurrence.pk)
+
+    def test_the_last_detection_cannot_be_removed(self):
+        self.occurrence.detections.exclude(pk=self.detections[0].pk).delete()
+        response = self.post("remove-detection", self.detections[0], user=self.curator)
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(self.occurrence.detections.count(), 1)
+
+    def test_every_track_edit_refreshes_the_session_and_station_counts(self):
+        """Each edit adds or removes an occurrence, and the session and station lists show cached counts.
+
+        The station refresh is queued after commit, so the test runs the queued task inline.
+        """
+        from ami.main.tasks import refresh_deployment_cached_counts
+
+        self.client.force_authenticate(user=self.curator)
+        url = f"/api/v2/occurrences/{self.occurrence.pk}"
+        edits = [
+            ("split-track", lambda: {"detection_id": self.detections[2].pk}, 2),
+            ("merge", lambda: {"occurrence_ids": [Detection.objects.get(pk=self.detections[2].pk).occurrence_id]}, 1),
+            ("remove-detection", lambda: {"detection_id": self.detections[1].pk}, 2),
+            ("add-detections", lambda: {"detection_ids": [self.detections[1].pk]}, 1),
+        ]
+        for action, body, expected in edits:
+            with mock.patch.object(
+                refresh_deployment_cached_counts, "delay", side_effect=refresh_deployment_cached_counts
+            ) as queued, self.captureOnCommitCallbacks(execute=True):
+                response = self.client.post(f"{url}/{action}/", body(), format="json")
+            self.assertEqual(response.status_code, 200, (action, response.data))
+            queued.assert_called_once_with([self.deployment.pk])
+            self.event.refresh_from_db()
+            self.deployment.refresh_from_db()
+            self.assertEqual(Occurrence.objects.filter(event=self.event).count(), expected, action)
+            self.assertEqual(self.event.occurrences_count, self.event.get_occurrences_count(), action)
+            self.assertEqual(self.deployment.occurrences_count, self.event.get_occurrences_count(), action)
+
+    def test_a_member_without_curation_rights_cannot_edit_a_track(self):
+        response = self.post("split-track", self.detections[2], user=self.reader)
+        self.assertEqual(response.status_code, 403)
+        self.assertEqual(self.occurrence.detections.count(), len(self.detections))
+
+    def test_anonymous_users_cannot_edit_a_track(self):
+        self.client.force_authenticate(user=None)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/split-track/",
+            {"detection_id": self.detections[2].pk},
+            format="json",
+        )
+        self.assertIn(response.status_code, (401, 403))
+        self.assertEqual(self.occurrence.detections.count(), len(self.detections))
+
+    def test_path_returns_a_frame_per_detection_earliest_first(self):
+        """The drawing payload: a box plus the dimensions of the capture it was measured in.
+
+        Without the capture's dimensions a neighbouring frame's box cannot be placed
+        on the frame being viewed, and no other payload carries them.
+        """
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/path/")
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual(len(response.data), len(self.detections))
+
+        timestamps = [frame["capture"]["timestamp"] for frame in response.data]
+        self.assertEqual(timestamps, sorted(timestamps), "Frames must run earliest first")
+
+        first = response.data[0]
+        self.assertEqual(first["detection_id"], self.detections[0].pk)
+        self.assertEqual(first["capture"]["id"], self.captures[0].pk)
+        self.assertEqual(first["bbox"], self.detections[0].bbox)
+        self.assertIn("width", first["capture"])
+        self.assertIn("height", first["capture"])
+
+    def test_path_carries_each_frame_crop_and_stays_null_when_there_is_none(self):
+        """A reviewer reading the animal in a frame they are not viewing needs its crop.
+
+        Crops are generated after detection, so a frame without one must come back as
+        null rather than a URL to nothing.
+        """
+        with_crop, without_crop = self.detections[0], self.detections[1]
+        with_crop.path = f"crops/{with_crop.pk}.jpg"
+        with_crop.save(update_fields=["path"])
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/path/")
+        self.assertEqual(response.status_code, 200, response.data)
+
+        crops = {frame["detection_id"]: frame["crop_url"] for frame in response.data}
+        self.assertIn(with_crop.path, crops[with_crop.pk])
+        self.assertIsNone(crops[without_crop.pk])
+
+    def test_path_order_matches_the_order_a_split_acts_on(self):
+        """A split moves the chosen detection and every later one.
+
+        The interface reads which frames move off this payload, so if the two
+        disagreed it would describe a split that keeps the wrong half.
+        """
+        self.client.force_authenticate(user=self.curator)
+        path = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/path/")
+        path_order = [frame["detection_id"] for frame in path.data]
+
+        boundary = path_order[2]
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/split-track/",
+            {"detection_id": boundary},
+            format="json",
+        )
+        moved = Occurrence.objects.get(pk=response.data["new_occurrence_id"])
+        self.assertEqual(
+            path_order[2:],
+            list(moved.detections.order_by("timestamp", "pk").values_list("pk", flat=True)),
+        )
+
+    def test_path_reads_every_frame_in_one_query(self):
+        """Frame count must not move the query count.
+
+        The fixture holds several frames, so a per-frame read would show up here as
+        several more queries. The occurrence is looked up without the detail
+        prefetch, which this payload never uses.
+        """
+        self.assertGreater(len(self.detections), 1, "A single-frame fixture cannot catch an N+1")
+        self.client.force_authenticate(user=self.curator)
+
+        with self.assertNumQueries(5):
+            response = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/path/")
+
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual(len(response.data), len(self.detections))
+
+    def test_path_is_readable_by_anyone_who_can_read_the_occurrence(self):
+        """Read-only, so it follows ordinary occurrence visibility rather than the edit gates.
+
+        A reader cannot split a track but must be able to look at its path, which is
+        the evidence the confirmation is based on.
+        """
+        self.client.force_authenticate(user=self.reader)
+        self.assertEqual(self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/path/").status_code, 200)
+
+        self.client.force_authenticate(user=None)
+        detail = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/")
+        path = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/path/")
+        self.assertEqual(
+            path.status_code,
+            detail.status_code,
+            "Path must be exactly as visible as the occurrence it describes",
+        )
+
+    def test_capture_payload_says_how_many_frames_an_occurrence_spans(self):
+        """The toolbar offers "N frames" or "one frame only" before asking for a path.
+
+        Counted in SQL through the detections prefetch, so the number of occurrences
+        drawn on a capture does not change the number of queries.
+        """
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.get(f"/api/v2/captures/{self.captures[0].pk}/?project_id={self.project.pk}")
+        self.assertEqual(response.status_code, 200, response.data)
+
+        occurrences = [d["occurrence"] for d in response.data["detections"] if d.get("occurrence")]
+        self.assertTrue(occurrences, "Fixture must put a detection with an occurrence on this capture")
+        self.assertEqual(occurrences[0]["detections_count"], len(self.detections))
+
+    def test_capture_payload_says_whether_a_grouping_was_confirmed(self):
+        """A capture's boxes carry the confirmation, so the toolbar can offer to undo it.
+
+        Without this the session view would have to fetch each occurrence separately to
+        find out, or would offer to confirm something a person had already confirmed.
+        """
+        self.client.force_authenticate(user=self.curator)
+        url = f"/api/v2/captures/{self.captures[0].pk}/?project_id={self.project.pk}"
+
+        response = self.client.get(url)
+        occurrence = next(d["occurrence"] for d in response.data["detections"] if d.get("occurrence"))
+        self.assertFalse(occurrence["grouping_verified"])
+        self.assertIsNone(occurrence["grouping_verified_by"])
+
+        self.curator.name = "Test Curator"
+        self.curator.save()
+        self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/verify-grouping/")
+
+        response = self.client.get(url)
+        occurrence = next(d["occurrence"] for d in response.data["detections"] if d.get("occurrence"))
+        self.assertTrue(occurrence["grouping_verified"])
+        self.assertIsNotNone(occurrence["grouping_verified_at"])
+        self.assertEqual(occurrence["grouping_verified_by"], "Test Curator")
+
+    def test_every_track_action_works_on_an_occurrence_the_list_would_hide(self):
+        """Restructuring and confirming a track never waits on the taxon being known.
+
+        The set of boxes that are one animal is a different question from which
+        taxon they are and how confident the model was, so neither the missing
+        determination of a detector-only project nor the project's score threshold
+        may gate these actions. They are how a human-annotated set gets built.
+        """
+        self.project.default_filters_score_threshold = 0.9
+        self.project.save()
+        undetermined, detections = self._make_track(3, score=None)
+        self.assertIsNone(undetermined.determination_id, "The fixture must have no determination")
+
+        self.client.force_authenticate(user=self.curator)
+        split = self.client.post(
+            f"/api/v2/occurrences/{undetermined.pk}/split-track/",
+            {"detection_id": detections[2].pk},
+            format="json",
+        )
+        self.assertEqual(split.status_code, 200, split.data)
+
+        removed = self.client.post(
+            f"/api/v2/occurrences/{undetermined.pk}/remove-detection/",
+            {"detection_id": detections[0].pk},
+            format="json",
+        )
+        self.assertEqual(removed.status_code, 200, removed.data)
+
+        verified = self.client.post(f"/api/v2/occurrences/{undetermined.pk}/verify-grouping/", format="json")
+        self.assertEqual(verified.status_code, 200, verified.data)
+        unverified = self.client.post(f"/api/v2/occurrences/{undetermined.pk}/unverify-grouping/", format="json")
+        self.assertEqual(unverified.status_code, 200, unverified.data)
+
+        below_threshold, _ = self._make_track(2, score=0.1)
+        confirmed = self.client.post(f"/api/v2/occurrences/{below_threshold.pk}/verify-grouping/", format="json")
+        self.assertEqual(confirmed.status_code, 200, confirmed.data)
+
+    def test_an_occurrence_with_no_determination_can_still_be_opened(self):
+        """The detail page opens before anyone has identified the animal.
+
+        A reviewer follows a box from a capture to the occurrence behind it, and on a
+        project where only a detector ran nothing is identified yet. The payload says
+        the determination is simply missing. The list is a separate judgement and goes
+        on showing determined occurrences only.
+        """
+        undetermined, _ = self._make_track(2, score=None)
+
+        self.client.force_authenticate(user=self.curator)
+        detail = self.client.get(f"/api/v2/occurrences/{undetermined.pk}/?project_id={self.project.pk}")
+        self.assertEqual(detail.status_code, 200, detail.data)
+        self.assertIsNone(detail.data["determination"])
+        self.assertIsNone(detail.data["determination_score"])
+        self.assertEqual(detail.data["detections_count"], 2)
+
+        path = self.client.get(f"/api/v2/occurrences/{undetermined.pk}/path/?project_id={self.project.pk}")
+        self.assertEqual(path.status_code, 200, "The frames a reviewer judges the grouping by open too")
+
+        listed = self.client.get(f"/api/v2/occurrences/?project_id={self.project.pk}")
+        self.assertNotIn(undetermined.pk, [row["id"] for row in listed.data["results"]])
+
+    def test_path_draws_an_occurrence_the_default_filters_hide(self):
+        """The session view selects occurrences with the default filters off, so their paths load.
+
+        The detail is the control: the same filters still hide the occurrence there.
+        """
+        self.project.default_filters_score_threshold = 0.9
+        self.project.save()
+        below_threshold, detections = self._make_track(3, score=0.1)
+
+        self.client.force_authenticate(user=self.reader)
+        detail = self.client.get(f"/api/v2/occurrences/{below_threshold.pk}/?project_id={self.project.pk}")
+        self.assertEqual(detail.status_code, 404, "The fixture must be hidden by the default filters")
+
+        path = self.client.get(f"/api/v2/occurrences/{below_threshold.pk}/path/?project_id={self.project.pk}")
+        self.assertEqual(path.status_code, 200, path.data)
+        self.assertEqual([frame["detection_id"] for frame in path.data], [d.pk for d in detections])
+
+    def test_path_of_a_draft_project_stays_private(self):
+        """Skipping the default filters must not skip the draft-project rule with them."""
+        self.project.draft = True
+        self.project.save()
+        outsider = User.objects.create_user(email="outsider@insectai.org")  # type: ignore[attr-defined]
+        url = f"/api/v2/occurrences/{self.occurrence.pk}/path/"
+
+        self.client.force_authenticate(user=self.reader)
+        self.assertEqual(self.client.get(url).status_code, 200)
+
+        self.client.force_authenticate(user=outsider)
+        self.assertEqual(self.client.get(url).status_code, 404)
+        self.assertEqual(self.client.get(f"{url}?project_id={self.project.pk}").status_code, 404)
+
+    def test_path_of_an_occurrence_with_no_real_box_is_not_found(self):
+        """An occurrence backed only by a null-marker detection has no box to draw.
+
+        The session list never offers one, and skipping the default filters must not
+        surface it either.
+        """
+        capture = self.captures[0]
+        phantom = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+        Detection.objects.create(source_image=capture, timestamp=capture.timestamp, bbox=None, occurrence=phantom)
+
+        self.client.force_authenticate(user=self.curator)
+        path = self.client.get(f"/api/v2/occurrences/{phantom.pk}/path/?project_id={self.project.pk}")
+        self.assertEqual(path.status_code, 404)
+
+    def test_split_reports_the_counts_the_edit_left_behind(self):
+        """Both counts come from the database, not from the prefetched detections.
+
+        The detail queryset prefetches an occurrence's detections, and the related
+        manager answers .count() from that cache, so a response built from it would
+        report the detections the split had just moved away.
+        """
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/split-track/",
+            {"detection_id": self.detections[2].pk},
+            format="json",
+        )
+        self.assertEqual(response.data["occurrence_detections_count"], 2)
+        self.assertEqual(response.data["new_occurrence_detections_count"], len(self.detections) - 2)
+
+
+class OccurrenceFramesTestCase(TrackFixtureTestCase):
+    """Paging through an occurrence's detections, which a long track has too many of to embed."""
+
+    def frames(self, query: str = "", occurrence: Occurrence | None = None):
+        occurrence = occurrence or self.occurrence
+        return self.client.get(f"/api/v2/occurrences/{occurrence.pk}/detections/?project_id={self.project.pk}{query}")
+
+    def test_frames_run_in_capture_order_with_their_index_in_the_track(self):
+        self.client.force_authenticate(user=self.reader)
+        first = self.frames("&limit=3")
+        self.assertEqual(first.status_code, 200, first.data)
+        self.assertEqual(first.data["count"], len(self.detections))
+        self.assertEqual([row["id"] for row in first.data["results"]], [d.pk for d in self.detections[:3]])
+        self.assertEqual([row["frame_index"] for row in first.data["results"]], [0, 1, 2])
+        self.assertEqual(first.data["results"][0]["capture"]["id"], self.captures[0].pk)
+        self.assertIsNone(first.data["previous"])
+
+        rest = self.client.get(first.data["next"])
+        self.assertEqual([row["id"] for row in rest.data["results"]], [self.detections[3].pk])
+        self.assertEqual([row["frame_index"] for row in rest.data["results"]], [3])
+        self.assertIsNone(rest.data["next"])
+
+    def test_around_opens_the_page_holding_that_frame(self):
+        """Opening the strip on a given frame needs its page, wherever it falls in the track."""
+        self.client.force_authenticate(user=self.reader)
+        response = self.frames(f"&limit=3&around={self.detections[3].pk}")
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual([row["frame_index"] for row in response.data["results"]], [3])
+        # The neighbouring page is addressed by offset, or following it would reopen this one.
+        self.assertNotIn("around", response.data["previous"])
+        self.assertEqual(
+            [row["frame_index"] for row in self.client.get(response.data["previous"]).data["results"]], [0, 1, 2]
+        )
+
+        self.assertEqual(
+            [row["frame_index"] for row in self.frames(f"&limit=3&around={self.detections[1].pk}").data["results"]],
+            [0, 1, 2],
+        )
+
+    def test_invalid_paging_parameters_are_rejected(self):
+        other, other_detections = self._make_track(1, captures=self._make_captures_after(1))
+        self.client.force_authenticate(user=self.reader)
+        for query in (
+            "&limit=abc",
+            "&limit=0",
+            "&offset=-1",
+            "&around=abc",
+            f"&around={other_detections[0].pk}",
+            f"&around={self.detections[0].pk}&offset=0",
+        ):
+            self.assertEqual(self.frames(query).status_code, 400, query)
+
+    def test_the_detail_embeds_the_first_page_and_the_track_ends(self):
+        """The detail renders the strip without a second request, so its frames must be the first page."""
+        from ami.main.api.serializers import OccurrenceSerializer
+
+        self.client.force_authenticate(user=self.reader)
+        with mock.patch.object(OccurrenceSerializer, "detections_page_size", 2):
+            detail = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/?project_id={self.project.pk}")
+        self.assertEqual(detail.status_code, 200, detail.data)
+        page = self.frames("&limit=2").data["results"]
+        self.assertEqual(detail.data["detections"], page)
+        self.assertEqual(detail.data["detections_count"], len(self.detections))
+        self.assertEqual(detail.data["first_detection"]["id"], self.detections[0].pk)
+        self.assertEqual(detail.data["last_detection"]["id"], self.detections[-1].pk)
+        self.assertEqual(detail.data["last_detection"]["frame_index"], len(self.detections) - 1)
+        self.assertEqual(detail.data["last_detection"]["capture_id"], self.captures[len(self.detections) - 1].pk)
+
+    def test_the_grouping_summary_names_the_labels_across_every_frame(self):
+        """The strip shows one page, so the per-label frame counts have to come from the server."""
+        other_taxon = Taxon.objects.filter(projects=self.project).exclude(pk=self.taxon.pk).first()
+        Classification.objects.filter(detection=self.detections[0]).update(taxon=other_taxon, score=0.5)
+        Classification.objects.filter(detection=self.detections[1]).delete()
+
+        self.client.force_authenticate(user=self.reader)
+        detail = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/?project_id={self.project.pk}")
+        names = [
+            (n["taxon"] and n["taxon"]["id"], n["frames"], n["score_max"])
+            for n in detail.data["grouping_summary"]["frame_names"]
+        ]
+        self.assertEqual(names, [(self.taxon.pk, 2, 0.9), (other_taxon.pk, 1, 0.5), (None, 1, None)])
+
+    def test_the_json_export_keeps_every_detection(self):
+        from ami.exports.format_types import get_export_serializer
+        from ami.exports.utils import generate_fake_request
+        from ami.main.api.serializers import OccurrenceSerializer
+
+        # The queryset the JSON export reads occurrences through.
+        occurrences = Occurrence.objects.filter(pk=self.occurrence.pk).with_timestamps()  # type: ignore[union-attr]
+        occurrence = occurrences.with_detections_count().with_identifications().with_detail_prefetches().get()
+        with mock.patch.object(OccurrenceSerializer, "detections_page_size", 2):
+            data = get_export_serializer()(occurrence, context={"request": generate_fake_request()}).data
+        self.assertEqual(len(data["detections"]), len(self.detections))
+        self.assertNotIn("first_detection", data)
+
+    def test_a_page_costs_the_same_queries_however_long_the_track(self):
+        """A per-frame read would add queries for the longer track."""
+        self.client.force_authenticate(user=self.reader)
+        long_track, _ = self._make_track(8, captures=self.captures + self._make_captures_after(4))
+        self.frames()  # warm up auth and pool state
+        with cachalot_disabled(), self.assertNumQueries(12):
+            short = self.frames()
+        with cachalot_disabled(), self.assertNumQueries(12):
+            long = self.frames(occurrence=long_track)
+        self.assertEqual(len(short.data["results"]), 4)
+        self.assertEqual(len(long.data["results"]), 8)
+
+    def test_frames_are_exactly_as_visible_as_the_occurrence(self):
+        """Read-only, so the detail's visibility applies, including on a draft project."""
+        outsider = User.objects.create_user(email="outsider@insectai.org")  # type: ignore[attr-defined]
+        superuser = User.objects.create_superuser(  # type: ignore[attr-defined]
+            email="frames-admin@insectai.org", password="secret"
+        )
+        detail_url = f"/api/v2/occurrences/{self.occurrence.pk}/?project_id={self.project.pk}"
+
+        for draft in (False, True):
+            self.project.draft = draft
+            self.project.save(update_fields=["draft"])
+            for user, expect_ok in ((self.reader, True), (superuser, True), (outsider, not draft), (None, not draft)):
+                self.client.force_authenticate(user=user)
+                frames = self.frames()
+                detail = self.client.get(detail_url)
+                label = (draft, user and user.email)
+                self.assertEqual(frames.status_code, detail.status_code, label)
+                self.assertEqual(frames.status_code == 200, expect_ok, label)
+
+
+class TrackingFlagGateTestCase(TrackFixtureTestCase):
+    """Track editing is refused on a project that has not opted into tracking.
+
+    Every track-editing endpoint answers 403 with a message naming the flag, whoever
+    asks, and leaves the occurrence untouched; reading occurrences is unaffected.
+    That the endpoints work once the flag is on is what TrackEditTestCase pins.
+    """
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.project.feature_flags.tracking = False
+        self.project.save(update_fields=["feature_flags"])
+        self.superuser = User.objects.create_superuser(email="tracking-gate-super@insectai.org")  # type: ignore
+        self.outsider = User.objects.create_user(email="tracking-gate-outsider@insectai.org")  # type: ignore
+        self.other, _ = self._make_track(1, captures=self._make_captures_after(1))
+
+    def _requests(self) -> dict[str, tuple[str, dict | None]]:
+        base = f"/api/v2/occurrences/{self.occurrence.pk}"
+        detection = {"detection_id": self.detections[2].pk}
+        return {
+            "split-track": (f"{base}/split-track/", detection),
+            "remove-detection": (f"{base}/remove-detection/", detection),
+            "merge": (f"{base}/merge/", {"occurrence_ids": [self.other.pk]}),
+            "add-detections": (f"{base}/add-detections/", {"detection_ids": [self.other.detections.get().pk]}),
+            "verify-grouping": (f"{base}/verify-grouping/", {}),
+            "unverify-grouping": (f"{base}/unverify-grouping/", {}),
+            "merge-candidates": (f"{base}/merge-candidates/?project_id={self.project.pk}", None),
+            "capture-matches": (f"{base}/capture-matches/?capture_id={self.captures[0].pk}", None),
+        }
+
+    def _call(self, url: str, body: dict | None):
+        if body is None:
+            return self.client.get(url)
+        return self.client.post(url, body, format="json")
+
+    def test_every_track_edit_is_refused_while_the_flag_is_off(self):
+        for user in (self.curator, self.superuser):
+            self.client.force_authenticate(user=user)
+            for name, (url, body) in self._requests().items():
+                with self.subTest(user=user.email, endpoint=name):
+                    response = self._call(url, body)
+                    self.assertEqual(response.status_code, 403, response.data)
+                    self.assertEqual(str(response.data["detail"]), "Tracking is not enabled for this project.")
+        self.assertEqual(self.occurrence.detections.count(), len(self.detections))
+        self.assertTrue(Occurrence.objects.filter(pk=self.other.pk).exists())
+        self.occurrence.refresh_from_db()
+        self.assertIsNone(self.occurrence.grouping_verified_at)
+
+    def test_users_without_rights_get_the_usual_refusal(self):
+        url, body = self._requests()["split-track"]
+        for label, user in (("member without curation rights", self.reader), ("non-member", self.outsider)):
+            with self.subTest(label):
+                self.client.force_authenticate(user=user)
+                response = self._call(url, body)
+                self.assertEqual(response.status_code, 403)
+                self.assertNotEqual(str(response.data["detail"]), "Tracking is not enabled for this project.")
+        self.client.force_authenticate(user=None)
+        self.assertIn(self._call(url, body).status_code, (401, 403))
+
+    def test_occurrences_stay_readable(self):
+        self.client.force_authenticate(user=self.reader)
+        detail = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/?project_id={self.project.pk}")
+        self.assertEqual(detail.status_code, 200)
+        self.assertIn("grouping_verified", detail.data)
+        path = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/path/?project_id={self.project.pk}")
+        self.assertEqual(path.status_code, 200)
+
+    def test_turning_the_flag_on_allows_the_edit(self):
+        enable_tracking(self.project)
+        response = self.post("split-track", self.detections[2], user=self.curator)
+        self.assertEqual(response.status_code, 200, response.data)
+
+
+class OccurrenceGroupingTestCase(TrackEditTestCase):
+    """Building the other half of a human-verified test set.
+
+    Splitting alone cannot produce ground truth: a reviewer also has to be able to
+    say "these two occurrences are one animal" and "this grouping is right as it
+    stands". What these pin is that neither of those loses data — a merge must
+    carry identifications across rather than cascade them away, and a confirmation
+    must not survive a later change to the detections it was given.
+    """
+
+    def _make_identification(self, occurrence: Occurrence) -> Identification:
+        return Identification.objects.create(occurrence=occurrence, taxon=self.taxon, user=self.curator)
+
+    def test_merge_moves_detections_and_identifications_to_the_survivor(self):
+        other, other_detections = self._make_track(2, captures=self._make_captures_after(2))
+        identification = self._make_identification(other)
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/merge/",
+            {"occurrence_ids": [other.pk]},
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.data)
+
+        self.assertEqual(response.data["detections_count"], len(self.detections) + len(other_detections))
+        self.assertFalse(Occurrence.objects.filter(pk=other.pk).exists())
+        identification.refresh_from_db()
+        self.assertEqual(
+            identification.occurrence_id,
+            self.occurrence.pk,
+            "A merge must carry identifications to the survivor, not cascade them away",
+        )
+
+    def test_merge_refuses_an_occurrence_from_another_session(self):
+        other_project, other_deployment = setup_test_project(reuse=False)
+        create_captures(deployment=other_deployment, num_nights=1, images_per_night=2, interval_minutes=1)
+        create_taxa(other_project)
+        create_occurrences(deployment=other_deployment, num=1)
+        foreign = Occurrence.objects.filter(project=other_project).first()
+        assert foreign is not None
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/merge/",
+            {"occurrence_ids": [foreign.pk]},
+            format="json",
+        )
+        self.assertEqual(response.status_code, 400)
+        foreign.refresh_from_db()
+        self.assertEqual(foreign.project_id, other_project.pk)
+
+    def _make_sessionless_track(self, project: Project, deployment: Deployment, length: int = 2) -> Occurrence:
+        """An occurrence on captures that were never grouped into a session."""
+        occurrence = Occurrence.objects.create(event=None, deployment=deployment, project=project)
+        start = self.captures[-1].timestamp + datetime.timedelta(hours=1)
+        for i in range(length):
+            capture = SourceImage.objects.create(
+                deployment=deployment,
+                event=None,
+                timestamp=start + datetime.timedelta(minutes=i),
+                path=f"test/ungrouped-{occurrence.pk}-{i}.jpg",
+            )
+            Detection.objects.create(
+                source_image=capture, timestamp=capture.timestamp, bbox=[10, 10, 40, 40], occurrence=occurrence
+            )
+        return occurrence
+
+    def test_merge_refuses_a_sessionless_occurrence_from_another_project(self):
+        """Two occurrences without a session have no session to compare, so a merge from a
+        public project into this one must still be refused and must not delete the source."""
+        other_project, other_deployment = setup_test_project(reuse=False)
+        target = self._make_sessionless_track(self.project, self.deployment)
+        foreign = self._make_sessionless_track(other_project, other_deployment)
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{target.pk}/merge/", {"occurrence_ids": [foreign.pk]}, format="json"
+        )
+        self.assertEqual(response.status_code, 400, response.data)
+        self.assertTrue(Occurrence.objects.filter(pk=foreign.pk, project=other_project).exists())
+        self.assertEqual(foreign.detections.count(), 2)
+
+    def test_track_edits_refuse_a_target_without_a_session(self):
+        """Every track edit and picker compares against the target's session, so a target
+        without one is a 400, not a 500 or a search across every ungrouped capture."""
+        target = self._make_sessionless_track(self.project, self.deployment)
+        other = self._make_sessionless_track(self.project, self.deployment)
+        detection = other.detections.first()
+        assert detection is not None
+        base = f"/api/v2/occurrences/{target.pk}"
+
+        self.client.force_authenticate(user=self.curator)
+        responses = {
+            "merge": self.client.post(f"{base}/merge/", {"occurrence_ids": [other.pk]}, format="json"),
+            "add-detections": self.client.post(
+                f"{base}/add-detections/", {"detection_ids": [detection.pk]}, format="json"
+            ),
+            "merge-candidates": self.client.get(f"{base}/merge-candidates/?project_id={self.project.pk}"),
+        }
+        for action, response in responses.items():
+            with self.subTest(action=action):
+                self.assertEqual(response.status_code, 400, getattr(response, "data", response))
+        self.assertEqual(other.detections.count(), 2)
+
+    def test_adding_a_detection_on_an_ungrouped_capture_is_refused(self):
+        """A capture that was never grouped belongs to no session, so its boxes cannot join a
+        track until the captures are grouped."""
+        capture = SourceImage.objects.create(
+            deployment=self.deployment,
+            event=None,
+            timestamp=self.captures[-1].timestamp + datetime.timedelta(minutes=5),
+            path="test/ungrouped-single.jpg",
+        )
+        bare = Detection.objects.create(
+            source_image=capture, timestamp=capture.timestamp, bbox=[60, 60, 90, 90], occurrence=None
+        )
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/add-detections/",
+            {"detection_ids": [bare.pk]},
+            format="json",
+        )
+        self.assertEqual(response.status_code, 400, response.data)
+        bare.refresh_from_db()
+        self.assertIsNone(bare.occurrence_id)
+
+    def test_merge_refuses_a_source_in_another_project_even_on_the_same_session(self):
+        """Occurrence and session projects are separate columns, so the project is checked on
+        its own rather than trusted to follow from the session."""
+        other_project, other_deployment = setup_test_project(reuse=False)
+        stray, _ = self._make_track(1, captures=self._make_captures_after(1))
+        Occurrence.objects.filter(pk=stray.pk).update(project=other_project, deployment=other_deployment)
+        stray.refresh_from_db()
+
+        with self.assertRaises(TrackEditError):
+            merge_occurrences(self.occurrence, [stray])
+        self.assertTrue(Occurrence.objects.filter(pk=stray.pk).exists())
+
+    def test_merge_refuses_a_source_on_a_capture_the_track_covers(self):
+        """One animal appears once per capture, so a source with a box on one of the track's
+        captures is a second individual and the whole merge is refused."""
+        other, _ = self._make_track(1)
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/merge/", {"occurrence_ids": [other.pk]}, format="json"
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertTrue(Occurrence.objects.filter(pk=other.pk).exists())
+        self.assertEqual(self.occurrence.detections.count(), len(self.detections))
+
+    def test_refusal_names_the_capture_times(self):
+        """The refusal is shown verbatim in the merge and extend dialogs, so it names the
+        capture times a reviewer sees on the session page rather than database ids."""
+        SourceImage.objects.filter(pk=self.captures[0].pk).update(timestamp=datetime.datetime(2026, 9, 1, 22, 48, 23))
+        SourceImage.objects.filter(pk=self.captures[1].pk).update(timestamp=datetime.datetime(2026, 9, 2, 0, 5, 7))
+        other, _ = self._make_track(2)
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/merge/", {"occurrence_ids": [other.pk]}, format="json"
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json()["occurrence_ids"],
+            "This would put two detections from the captures at 10:48:23 PM, 12:05:07 AM into one occurrence. "
+            "One animal appears once per capture, so these are different individuals.",
+        )
+
+    def test_merge_refuses_two_sources_on_the_same_capture(self):
+        """Two sources that each have a box on the same capture are two individuals, even when
+        the track itself does not cover that capture, as when every candidate is ticked at once."""
+        capture = self._make_captures_after(1)
+        first, _ = self._make_track(1, captures=capture)
+        second, _ = self._make_track(1, captures=capture)
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/merge/",
+            {"occurrence_ids": [first.pk, second.pk]},
+            format="json",
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(Occurrence.objects.filter(pk__in=[first.pk, second.pk]).count(), 2)
+
+    def test_adding_a_detection_on_a_covered_capture_is_refused(self):
+        """Adding a box on a capture the track already covers would give it two boxes there."""
+        stray, stray_detections = self._make_track(1)
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/add-detections/",
+            {"detection_ids": [stray_detections[0].pk]},
+            format="json",
+        )
+        self.assertEqual(response.status_code, 400)
+        stray_detections[0].refresh_from_db()
+        self.assertEqual(stray_detections[0].occurrence_id, stray.pk)
+
+    def test_adding_a_stray_detection_absorbs_the_occurrence_it_emptied(self):
+        stray, stray_detections = self._make_track(1, captures=self._make_captures_after(1))
+        identification = self._make_identification(stray)
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/add-detections/",
+            {"detection_ids": [stray_detections[0].pk]},
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.data)
+
+        self.assertEqual(response.data["detections_count"], len(self.detections) + 1)
+        self.assertFalse(Occurrence.objects.filter(pk=stray.pk).exists())
+        identification.refresh_from_db()
+        self.assertEqual(identification.occurrence_id, self.occurrence.pk)
+
+    def test_a_detection_without_an_occurrence_can_be_added(self):
+        """A box that tracking never grouped is still part of the session and can join a track.
+
+        A project where only a detector ran leaves most of its boxes with no
+        occurrence at all, and a hand-built track is assembled out of exactly those.
+        They carry no occurrence to read a project from, so the endpoint has to scope
+        them through the capture they were found in.
+        """
+        capture = self._make_captures_after(1)[0]
+        bare = Detection.objects.create(
+            source_image=capture,
+            timestamp=capture.timestamp,
+            bbox=[60, 60, 90, 90],
+            occurrence=None,
+        )
+
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/add-detections/",
+            {"detection_ids": [bare.pk]},
+            format="json",
+        )
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual(response.data["detections_count"], len(self.detections) + 1)
+
+        bare.refresh_from_db()
+        self.assertEqual(bare.occurrence_id, self.occurrence.pk)
+
+    def test_a_chain_link_never_crosses_an_occurrence_boundary(self):
+        # Take the middle detection out of its track; the link that pointed into it
+        # from the detection left behind must not survive the move.
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/add-detections/",
+            {"detection_ids": [self.detections[1].pk]},
+            format="json",
+        )
+        # It is already in this occurrence, so this is a no-op the API rejects.
+        self.assertEqual(response.status_code, 400)
+
+        other, other_detections = self._make_track(3, captures=self._make_captures_after(3))
+        self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/add-detections/",
+            {"detection_ids": [other_detections[1].pk]},
+            format="json",
+        )
+        moved = Detection.objects.get(pk=other_detections[1].pk)
+        self.assertEqual(moved.occurrence_id, self.occurrence.pk)
+        self.assertIsNone(moved.next_detection_id, "Outbound link to a detection left behind must be cut")
+        self.assertFalse(
+            Detection.objects.filter(next_detection_id=moved.pk).exclude(occurrence_id=self.occurrence.pk).exists(),
+            "Inbound link from a detection left behind must be cut",
+        )
+
+    def test_verifying_records_who_and_when(self):
+        self.client.force_authenticate(user=self.curator)
+        response = self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/verify-grouping/", format="json")
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertTrue(response.data["grouping_verified"])
+        self.assertIsNotNone(response.data["grouping_verified_at"])
+
+        self.occurrence.refresh_from_db()
+        self.assertEqual(self.occurrence.grouping_verified_by_id, self.curator.pk)
+
+    def test_changing_the_detections_withdraws_the_confirmation(self):
+        self.client.force_authenticate(user=self.curator)
+        self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/verify-grouping/", format="json")
+        self.occurrence.refresh_from_db()
+        self.assertTrue(self.occurrence.grouping_verified)
+
+        self.post("split-track", self.detections[2], user=self.curator)
+
+        self.occurrence.refresh_from_db()
+        self.assertFalse(
+            self.occurrence.grouping_verified,
+            "A person confirmed the detections they were shown, not the ones left after an edit",
+        )
+
+    def test_unverifying_leaves_the_detections_alone(self):
+        self.client.force_authenticate(user=self.curator)
+        self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/verify-grouping/", format="json")
+        response = self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/unverify-grouping/", format="json")
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertFalse(response.data["grouping_verified"])
+        self.assertEqual(self.occurrence.detections.count(), len(self.detections))
+
+    def test_identifying_rights_allow_confirming_but_not_restructuring(self):
+        identifier = User.objects.create_user(email="identifier-grouping@insectai.org")  # type: ignore[attr-defined]
+        Identifier.assign_user(identifier, self.project)
+
+        self.client.force_authenticate(user=identifier)
+        confirm = self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/verify-grouping/", format="json")
+        self.assertEqual(confirm.status_code, 200, confirm.data)
+
+        restructure = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/split-track/",
+            {"detection_id": self.detections[2].pk},
+            format="json",
+        )
+        self.assertEqual(restructure.status_code, 403)
+
+    def test_detail_advertises_the_rights_the_track_actions_need(self):
+        """The interface decides which controls to draw from these permissions.
+
+        Restructuring is gated on the occurrence delete right and confirming on
+        either right, so a reader who is offered a split button would only meet a
+        403 after clicking it.
+        """
+        self.client.force_authenticate(user=self.curator)
+        curator_view = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/")
+        self.assertIn("delete", curator_view.data["user_permissions"])
+
+        self.client.force_authenticate(user=self.reader)
+        reader_view = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/")
+        self.assertNotIn("delete", reader_view.data["user_permissions"])
+
+    def test_detail_reports_the_grouping_confirmation(self):
+        self.client.force_authenticate(user=self.curator)
+        before = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/")
+        self.assertFalse(before.data["grouping_verified"])
+        self.assertIsNone(before.data["grouping_verified_by"])
+
+        self.client.post(f"/api/v2/occurrences/{self.occurrence.pk}/verify-grouping/", format="json")
+
+        after = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/")
+        self.assertTrue(after.data["grouping_verified"])
+        self.assertIsNotNone(after.data["grouping_verified_at"])
+        self.assertEqual(after.data["grouping_verified_by"]["id"], self.curator.pk)
+        self.assertNotIn("email", after.data["grouping_verified_by"])
+
+
+class TrackChainAfterEditTestCase(TrackFixtureTestCase):
+    """Every manual edit leaves each occurrence it touched linked frame to frame.
+
+    A confirmed occurrence is the ground truth a tracking benchmark is scored against,
+    and the tracks export carries its chain as ``next_detection_id``. An edit that
+    changes the membership without relinking leaves gaps in that chain.
+    """
+
+    def _chain(self, occurrence: Occurrence) -> list[tuple[int, int | None]]:
+        return list(
+            occurrence.detections.order_by("source_image__timestamp", "pk").values_list("pk", "next_detection_id")
+        )
+
+    def assertFullyLinked(self, occurrence: Occurrence) -> None:
+        chain = self._chain(occurrence)
+        expected = [(pk, next_pk) for (pk, _), (next_pk, _) in zip(chain, chain[1:])] + [(chain[-1][0], None)]
+        self.assertEqual(chain, expected)
+
+    def test_split_leaves_both_pieces_linked(self):
+        new_occurrence = split_track(self.occurrence, self.detections[2])
+        self.assertFullyLinked(self.occurrence)
+        self.assertFullyLinked(new_occurrence)
+
+    def test_detaching_a_middle_frame_leaves_the_rest_linked(self):
+        new_occurrence = detach_detection(self.occurrence, self.detections[1])
+        self.assertFullyLinked(self.occurrence)
+        self.assertFullyLinked(new_occurrence)
+
+    def test_merge_links_the_merged_frames_in_capture_order(self):
+        after = self._make_captures_after(3)
+        other, _ = self._make_track(2, captures=[after[0], after[2]])
+        loose, _ = self._make_track(1, captures=[after[1]])
+
+        merge_occurrences(self.occurrence, [other, loose])
+
+        self.assertEqual(len(self._chain(self.occurrence)), 7)
+        self.assertFullyLinked(self.occurrence)
+
+    def test_adding_a_frame_links_it_in_and_stitches_the_donor(self):
+        donor, donor_detections = self._make_track(3, captures=self._make_captures_after(3))
+
+        add_detections(self.occurrence, [donor_detections[1]])
+
+        self.assertFullyLinked(self.occurrence)
+        self.assertFullyLinked(donor)
+        self.assertEqual(Detection.objects.get(pk=donor_detections[0].pk).next_detection_id, donor_detections[2].pk)
+
+    def test_an_edit_keeps_the_box_the_chain_already_runs_through_on_a_shared_capture(self):
+        """Older tracker output can hold two boxes on one capture; relinking must not swap them."""
+        second_box = Detection.objects.create(
+            source_image=self.captures[1],
+            timestamp=self.captures[1].timestamp,
+            bbox=[100, 100, 140, 140],
+            occurrence=self.occurrence,
+        )
+        Detection.objects.filter(pk=self.detections[1].pk).update(next_detection=None)
+        Detection.objects.filter(pk=self.detections[0].pk).update(next_detection=second_box)
+        Detection.objects.filter(pk=second_box.pk).update(next_detection=self.detections[2])
+
+        split_track(self.occurrence, self.detections[3])
+
+        self.assertEqual(Detection.objects.get(pk=self.detections[0].pk).next_detection_id, second_box.pk)
+        self.assertEqual(Detection.objects.get(pk=second_box.pk).next_detection_id, self.detections[2].pk)
+        self.assertIsNone(Detection.objects.get(pk=self.detections[1].pk).next_detection_id)
+
+    def _interleave_chains(self) -> None:
+        """Link the four frames as two tracks on alternating captures, 0→2 and 1→3: the shape
+        two merged tracks keep inside one occurrence if their chains are not rebuilt."""
+        d = self.detections
+        Detection.objects.filter(pk__in=[x.pk for x in d]).update(next_detection=None)
+        Detection.objects.filter(pk=d[0].pk).update(next_detection=d[2])
+        Detection.objects.filter(pk=d[1].pk).update(next_detection=d[3])
+
+    def assertNoLinkLeaves(self, occurrence: Occurrence) -> None:
+        """No link runs into or out of ``occurrence``; the next tracking run would follow one."""
+        outgoing = Detection.objects.filter(occurrence=occurrence, next_detection__isnull=False).exclude(
+            next_detection__occurrence=occurrence
+        )
+        incoming = Detection.objects.filter(next_detection__occurrence=occurrence).exclude(occurrence=occurrence)
+        self.assertEqual(list(outgoing.values_list("pk", flat=True)), [])
+        self.assertEqual(list(incoming.values_list("pk", flat=True)), [])
+
+    def test_splitting_interleaved_tracks_leaves_no_link_across_the_cut(self):
+        self._interleave_chains()
+
+        tail = split_track(self.occurrence, self.detections[2])
+
+        self.assertNoLinkLeaves(self.occurrence)
+        self.assertNoLinkLeaves(tail)
+
+    def test_detaching_from_interleaved_tracks_leaves_no_link_into_the_frame(self):
+        self._interleave_chains()
+
+        detached = detach_detection(self.occurrence, self.detections[2])
+
+        self.assertNoLinkLeaves(self.occurrence)
+        self.assertNoLinkLeaves(detached)
+
+    def test_splitting_after_merging_alternating_tracks_leaves_no_link_across_the_cut(self):
+        after = self._make_captures_after(4)
+        first, first_detections = self._make_track(2, captures=[after[0], after[2]])
+        second, _ = self._make_track(2, captures=[after[1], after[3]])
+
+        merge_occurrences(first, [second])
+        tail = split_track(first, first_detections[1])
+
+        self.assertNoLinkLeaves(first)
+        self.assertNoLinkLeaves(tail)
+
+    def test_a_merge_spanning_two_sessions_links_nothing_across_them(self):
+        later_session = Event.objects.create(
+            project=self.project,
+            deployment=self.deployment,
+            group_by="later-session",
+            start=self.captures[-1].timestamp + datetime.timedelta(days=1),
+        )
+        captures = [
+            SourceImage.objects.create(
+                deployment=self.deployment,
+                event=later_session,
+                timestamp=later_session.start + datetime.timedelta(minutes=i),
+                path=f"test/later-session-{i}.jpg",
+            )
+            for i in range(2)
+        ]
+        # Filed under this session although its captures are in the next one.
+        other, other_detections = self._make_track(2, captures=captures)
+
+        merge_occurrences(self.occurrence, [other])
+
+        self.assertIsNone(Detection.objects.get(pk=self.detections[-1].pk).next_detection_id)
+        self.assertEqual(Detection.objects.get(pk=other_detections[0].pk).next_detection_id, other_detections[1].pk)
+
+    def test_an_edited_and_confirmed_track_exports_an_unbroken_chain(self):
+        from ami.exports.tracks import iter_track_rows
+
+        after = self._make_captures_after(3)
+        other, _ = self._make_track(1, captures=[after[0]])
+        donor, donor_detections = self._make_track(2, captures=after[1:])
+        merge_occurrences(self.occurrence, [other])
+        add_detections(self.occurrence, [donor_detections[0]])
+        detach_detection(self.occurrence, self.detections[1])
+        add_detections(self.occurrence, [Detection.objects.get(pk=self.detections[1].pk)])
+        verify_grouping(self.occurrence, self.curator)
+
+        rows = list(iter_track_rows(Occurrence.objects.filter(pk=self.occurrence.pk)))
+
+        self.assertEqual(len(rows), 6)
+        self.assertEqual([row["next_detection_id"] for row in rows], [row["detection_id"] for row in rows[1:]] + [""])
+
+    def test_the_export_lists_frames_in_chain_order_when_two_captures_share_a_timestamp(self):
+        from ami.exports.tracks import iter_track_rows
+
+        timestamp = self.captures[-1].timestamp + datetime.timedelta(minutes=1)
+        earlier, later = (
+            SourceImage.objects.create(
+                deployment=self.deployment, event=self.event, timestamp=timestamp, path=f"test/same-time-{i}.jpg"
+            )
+            for i in range(2)
+        )
+        # The detection on the later capture gets the lower pk.
+        other, _ = self._make_track(1, captures=[later])
+        loose, _ = self._make_track(1, captures=[earlier])
+        merge_occurrences(self.occurrence, [other, loose])
+
+        rows = list(iter_track_rows(Occurrence.objects.filter(pk=self.occurrence.pk)))
+
+        self.assertEqual([row["next_detection_id"] for row in rows], [row["detection_id"] for row in rows[1:]] + [""])
+
+    def test_relinking_a_merge_costs_the_same_queries_however_many_frames_moved(self):
+        """Two reads and two writes, with no read or write per detection."""
+        other, _ = self._make_track(3, captures=self._make_captures_after(3))
+        Detection.objects.filter(occurrence__in=[self.occurrence, other]).update(occurrence=self.occurrence)
+        self.assertGreater(len(self._chain(self.occurrence)), 2, "A two-frame fixture cannot catch a per-row query")
+
+        with self.assertNumQueries(4):
+            relink_occurrence_chains([self.occurrence])
+
+        self.assertFullyLinked(self.occurrence)
+
+    def test_a_multi_frame_merge_does_not_query_per_frame(self):
+        other, _ = self._make_track(3, captures=self._make_captures_after(3))
+
+        with self.assertNumQueries(34):
+            merge_occurrences(self.occurrence, [other])
+
+        self.assertFullyLinked(self.occurrence)
+
+
+class OccurrenceGroupingVerifiedFilterTestCase(APITestCase):
+    """Finding the tracks nobody has signed off on yet.
+
+    Building a verified test set means working through a session confirming groupings
+    one at a time, which only works if the list can show what is left to do.
+    """
+
+    def setUp(self) -> None:
+        from ami.main.models_future.tracks import verify_grouping
+
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_taxa(project=self.project)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=4, interval_minutes=1)
+        create_occurrences(deployment=self.deployment, num=2)
+
+        self.verified, self.unverified = Occurrence.objects.filter(project=self.project).order_by("pk")
+        self.curator = User.objects.create_user(email="grouping-filter@insectai.org")  # type: ignore[attr-defined]
+        MLDataManager.assign_user(self.curator, self.project)
+        verify_grouping(self.verified, self.curator)
+        self.client.force_authenticate(user=self.curator)
+        return super().setUp()
+
+    def _listed(self, **params) -> set[int]:
+        query = "".join(f"&{key}={value}" for key, value in params.items())
+        response = self.client.get(f"/api/v2/occurrences/?project_id={self.project.pk}&limit=100{query}")
+        self.assertEqual(response.status_code, 200, response.data)
+        return {row["id"] for row in response.data["results"]}
+
+    def test_true_keeps_only_confirmed_tracks(self):
+        self.assertEqual(self._listed(grouping_verified="true"), {self.verified.pk})
+
+    def test_false_keeps_only_unconfirmed_tracks(self):
+        self.assertEqual(self._listed(grouping_verified="false"), {self.unverified.pk})
+
+    def test_omitting_the_parameter_keeps_both(self):
+        self.assertEqual(self._listed(), {self.verified.pk, self.unverified.pk})
+
+    def test_an_unparseable_value_is_refused(self):
+        """A typo must not quietly read as "unconfirmed" and hide half the session."""
+        response = self.client.get(f"/api/v2/occurrences/?project_id={self.project.pk}&grouping_verified=abc")
+        self.assertEqual(response.status_code, 400, response.data)
+
+
+class MergeCandidatesTestCase(TrackEditTestCase):
+    """Offering the right occurrence to merge with.
+
+    A session holds thousands of occurrences and two individuals of the same species
+    look alike as crops, so the picker has to be ranked the way tracking would have
+    ranked them, and has to say where each candidate sits in time. What these pin is
+    that the ranking follows the tracking cost, that the time relation is signed the
+    right way, that a candidate without a vector is still offered, that the search
+    covers the adjacent captures by default, that a candidate sharing a capture with
+    the track is never offered, and that one filling a gap in the track is, scored
+    against the track frame nearest it.
+    """
+
+    FRAME_SIZE = 1000
+
+    def setUp(self) -> None:
+        super().setUp()
+        for capture in self.captures:
+            capture.width = capture.height = self.FRAME_SIZE
+            capture.save(update_fields=["width", "height"])
+        self.before_capture = self._make_capture(self.captures[0].timestamp - datetime.timedelta(minutes=2))
+        self.after_capture = self._make_capture(self.captures[-1].timestamp + datetime.timedelta(minutes=2))
+
+    def _make_capture(self, timestamp: datetime.datetime) -> SourceImage:
+        return SourceImage.objects.create(
+            deployment=self.deployment,
+            event=self.event,
+            timestamp=timestamp,
+            path=f"test/{timestamp:%H%M%S}.jpg",
+            width=self.FRAME_SIZE,
+            height=self.FRAME_SIZE,
+        )
+
+    def _make_occurrence(
+        self,
+        captures: list[SourceImage],
+        bbox: list[int],
+        vector: list[float] | None = None,
+        algorithm: Algorithm | None = None,
+        score: float | None = 0.9,
+    ) -> Occurrence:
+        """One occurrence with a box in each of ``captures``.
+
+        A ``score`` of None leaves the detections unclassified, so the occurrence has
+        no determination: the shape every occurrence has on a project where only a
+        detector ran.
+        """
+        occurrence = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+        for capture in captures:
+            detection = Detection.objects.create(
+                source_image=capture,
+                timestamp=capture.timestamp,
+                bbox=bbox,
+                occurrence=occurrence,
+                path=f"crops/{capture.pk}-{bbox[0]}.jpg",
+            )
+            if score is not None:
+                detection.classifications.create(
+                    taxon=self.taxon,
+                    score=score,
+                    timestamp=capture.timestamp,
+                    algorithm=algorithm,
+                    features_2048=vector,
+                )
+        occurrence.save()
+        return occurrence
+
+    def _give_target_vectors(self, vector: list[float], algorithm: Algorithm) -> None:
+        for detection in self.detections:
+            detection.classifications.create(
+                taxon=self.taxon,
+                score=0.9,
+                timestamp=detection.timestamp,
+                algorithm=algorithm,
+                features_2048=vector,
+            )
+
+    def get_candidates(self, query: str = "", user: User | None = None):
+        self.client.force_authenticate(user=user or self.curator)
+        return self.client.get(
+            f"/api/v2/occurrences/{self.occurrence.pk}/merge-candidates/?project_id={self.project.pk}{query}"
+        )
+
+    def test_the_closest_box_ranks_first(self):
+        """Two candidates in the frame after the track ends, one on top of the last box and one
+        across the frame. Distance is the centre gap over the diagonal of a 1000x1000 frame."""
+        near = self._make_occurrence([self.after_capture], bbox=[12, 12, 42, 42])
+        far = self._make_occurrence([self.after_capture], bbox=[500, 500, 530, 530])
+
+        response = self.get_candidates()
+        self.assertEqual(response.status_code, 200, response.data)
+
+        rows = response.data["candidates"]
+        self.assertEqual([row["id"] for row in rows], [near.pk, far.pk])
+        self.assertLess(rows[0]["cost"], rows[1]["cost"])
+        self.assertAlmostEqual(rows[0]["distance"], 0.002, delta=0.001)
+        self.assertAlmostEqual(rows[1]["distance"], 0.49, delta=0.001)
+        self.assertEqual(rows[0]["determination"]["name"], self.taxon.name)
+        self.assertEqual(rows[0]["detections_count"], 1)
+        self.assertTrue(rows[0]["image"], "A candidate must come with a crop to recognise it by")
+
+    def _make_gap_capture(self) -> SourceImage:
+        """A capture inside the track's span that the track has no frame on."""
+        return self._make_capture(self.captures[1].timestamp + datetime.timedelta(seconds=30))
+
+    def test_the_time_relation_is_signed_from_the_track_being_edited(self):
+        before = self._make_occurrence([self.before_capture], bbox=[10, 10, 40, 40])
+        after = self._make_occurrence([self.after_capture], bbox=[10, 10, 40, 40])
+        in_gap = self._make_occurrence([self._make_gap_capture()], bbox=[10, 10, 40, 40])
+
+        by_id = {row["id"]: row for row in self.get_candidates().data["candidates"]}
+
+        self.assertEqual(by_id[before.pk]["relation"], "before")
+        self.assertEqual(by_id[before.pk]["time_offset_seconds"], -120.0)
+        self.assertEqual(by_id[after.pk]["relation"], "after")
+        self.assertEqual(by_id[after.pk]["time_offset_seconds"], 120.0)
+        self.assertEqual(by_id[in_gap.pk]["relation"], "gap")
+        self.assertEqual(by_id[in_gap.pk]["time_offset_seconds"], 0.0)
+
+    def test_a_candidate_without_a_vector_is_scored_on_geometry_alone(self):
+        """Similarity needs a vector on both frames from the same algorithm. Without one the
+        candidate is still offered, with the cost tracking would have used in that case."""
+        extractor = Algorithm.objects.create(name="Feature extractor", key="feature-extractor")
+        other_extractor = Algorithm.objects.create(name="Other extractor", key="other-extractor")
+        vector = [1.0] + [0.0] * 2047
+        self._give_target_vectors(vector, extractor)
+
+        matching = self._make_occurrence(
+            [self.after_capture], bbox=[12, 12, 42, 42], vector=vector, algorithm=extractor
+        )
+        unembedded = self._make_occurrence([self.after_capture], bbox=[12, 12, 42, 42])
+        foreign = self._make_occurrence(
+            [self.after_capture], bbox=[12, 12, 42, 42], vector=vector, algorithm=other_extractor
+        )
+
+        response = self.get_candidates()
+        by_id = {row["id"]: row for row in response.data["candidates"]}
+
+        self.assertEqual(by_id[matching.pk]["similarity"], 1.0)
+        self.assertIsNone(by_id[unembedded.pk]["similarity"])
+        self.assertIsNone(by_id[foreign.pk]["similarity"], "A vector from another algorithm is not comparable")
+
+        geometry_only = total_cost(
+            None, None, [10, 10, 40, 40], [12, 12, 42, 42], image_diagonal(self.FRAME_SIZE, self.FRAME_SIZE)
+        )
+        self.assertAlmostEqual(by_id[unembedded.pk]["cost"], geometry_only, places=4)
+        self.assertAlmostEqual(by_id[matching.pk]["cost"], geometry_only, places=4)
+
+    def test_candidates_carry_every_term_of_the_cost_and_the_trackers_decision(self):
+        """The picker shows the numbers tracking decides on: each term of the cost, the
+        likelihood, the threshold, and whether the pair falls under it. A candidate with
+        no vector never would link while tracking requires embeddings, however close
+        its box, and the terms are those of the tracking method, not a UI estimate."""
+        extractor = Algorithm.objects.create(name="Feature extractor", key="feature-extractor")
+        vector = [1.0] + [0.0] * 2047
+        self._give_target_vectors(vector, extractor)
+        track_box, far_box = [10, 10, 40, 40], [500, 500, 560, 560]
+        same_box = self._make_occurrence([self.after_capture], bbox=track_box, vector=vector, algorithm=extractor)
+        unembedded = self._make_occurrence([self.after_capture], bbox=track_box)
+        far = self._make_occurrence([self.after_capture], bbox=far_box, vector=vector, algorithm=extractor)
+
+        response = self.get_candidates()
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual(response.data["cost_threshold"], TrackingConfig(event_ids=[self.event.pk]).cost_threshold)
+        self.assertTrue(response.data["requires_features"])
+        by_id = {row["id"]: row for row in response.data["candidates"]}
+
+        self.assertEqual(by_id[same_box.pk]["cost"], 0.0)
+        self.assertEqual(by_id[same_box.pk]["iou"], 1.0)
+        self.assertEqual(by_id[same_box.pk]["size_ratio"], 1.0)
+        self.assertEqual(by_id[same_box.pk]["likelihood"], 1.0)
+        self.assertTrue(by_id[same_box.pk]["would_link"])
+
+        self.assertEqual(by_id[unembedded.pk]["cost"], 0.0, "Geometry alone scores a perfect fit")
+        self.assertFalse(by_id[unembedded.pk]["would_link"], "Tracking skips a frame without a vector")
+
+        self.assertEqual(by_id[far.pk]["iou"], 0.0)
+        self.assertAlmostEqual(by_id[far.pk]["size_ratio"], box_ratio(track_box, far_box), places=4)
+        self.assertLess(by_id[far.pk]["likelihood"], by_id[same_box.pk]["likelihood"])
+        self.assertFalse(by_id[far.pk]["would_link"])
+
+    def test_adjacent_captures_are_searched_by_default(self):
+        """The default search is the one capture on either side of the track, since that is
+        where the frame continuing it sits; `captures` widens it by count and `minutes` by time."""
+        next_capture = self._make_capture(self.after_capture.timestamp + datetime.timedelta(minutes=1))
+        adjacent = self._make_occurrence([self.after_capture], bbox=[10, 10, 40, 40])
+        one_further = self._make_occurrence([next_capture], bbox=[10, 10, 40, 40])
+
+        default_ids = [row["id"] for row in self.get_candidates().data["candidates"]]
+        self.assertEqual(default_ids, [adjacent.pk])
+
+        two_capture_ids = [row["id"] for row in self.get_candidates("&captures=2").data["candidates"]]
+        self.assertEqual(sorted(two_capture_ids), sorted([adjacent.pk, one_further.pk]))
+
+        window_ids = [row["id"] for row in self.get_candidates("&minutes=15").data["candidates"]]
+        self.assertEqual(sorted(window_ids), sorted([adjacent.pk, one_further.pk]))
+
+    def _make_same_capture_occurrences(self, count: int, bbox: list[int]) -> list[Occurrence]:
+        """`count` single-frame occurrences spread over the track's own captures, each with
+        its box at `bbox`, written in bulk so a dense session is cheap to set up."""
+        occurrences = Occurrence.objects.bulk_create(
+            Occurrence(
+                event=self.event,
+                deployment=self.deployment,
+                project=self.project,
+                determination=self.taxon,
+                determination_score=0.9,
+            )
+            for _ in range(count)
+        )
+        Detection.objects.bulk_create(
+            Detection(
+                source_image=capture,
+                timestamp=capture.timestamp,
+                bbox=bbox,
+                occurrence=occurrence,
+                path=f"crops/{capture.pk}-{occurrence.pk}.jpg",
+            )
+            for occurrence, capture in zip(occurrences, itertools.cycle(self.captures))
+        )
+        return occurrences
+
+    def test_a_candidate_on_one_of_the_tracks_captures_is_never_offered(self):
+        """One animal cannot appear twice in one capture, so an occurrence sharing a capture with
+        the track is another animal, in either search mode. The second one shares a capture
+        halfway through the track, beyond a one-minute window of either end, and has a frame
+        just after the track that both searches reach."""
+        mid_capture = self._make_gap_capture()
+        Detection.objects.create(
+            source_image=mid_capture,
+            timestamp=mid_capture.timestamp,
+            bbox=[10, 10, 40, 40],
+            occurrence=self.occurrence,
+        )
+        just_after = self._make_capture(self.captures[-1].timestamp + datetime.timedelta(seconds=30))
+        self._make_occurrence([self.captures[1]], bbox=[12, 12, 42, 42])
+        self._make_occurrence([mid_capture, just_after], bbox=[12, 12, 42, 42])
+        neighbour = self._make_occurrence([just_after], bbox=[500, 500, 530, 530])
+
+        for query in ("", "&minutes=1"):
+            ids = [row["id"] for row in self.get_candidates(query).data["candidates"]]
+            self.assertEqual(ids, [neighbour.pk], query)
+
+    def test_a_candidate_in_a_gap_of_the_track_is_offered(self):
+        """A candidate on a capture inside the track's span that the track has no frame on is
+        where tracking lost the animal for a capture, so it is offered by default."""
+        in_gap = self._make_occurrence([self._make_gap_capture()], bbox=[10, 10, 40, 40])
+
+        rows = self.get_candidates().data["candidates"]
+
+        self.assertEqual([(row["id"], row["relation"]) for row in rows], [(in_gap.pk, "gap")])
+
+    def test_a_dense_session_offers_only_the_true_neighbour(self):
+        """In a dense session the occurrences on the track's own captures outnumber the one
+        that could continue it and sit closer to its box, and none of them is offered."""
+        self._make_same_capture_occurrences(60, bbox=[10, 10, 40, 40])
+        neighbour = self._make_occurrence([self.after_capture], bbox=[14, 14, 44, 44])
+
+        response = self.get_candidates()
+
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual([row["id"] for row in response.data["candidates"]], [neighbour.pk])
+
+    def test_the_pair_frames_are_returned_for_comparison(self):
+        """Each row names both frames of the scored pair so the two crops can be shown side by
+        side: the track's first frame against a candidate before it, its last against one after."""
+        for detection in self.detections:
+            detection.path = f"crops/track-{detection.pk}.jpg"
+            detection.save(update_fields=["path"])
+        before = self._make_occurrence([self.before_capture], bbox=[10, 10, 40, 40])
+        after = self._make_occurrence([self.after_capture], bbox=[10, 10, 40, 40])
+
+        by_id = {row["id"]: row for row in self.get_candidates().data["candidates"]}
+
+        first, last = self.detections[0], self.detections[-1]
+        self.assertEqual(by_id[before.pk]["edge_image"], get_media_url(first.path))
+        self.assertEqual(by_id[before.pk]["edge_timestamp"], first.timestamp.isoformat())
+        self.assertEqual(by_id[before.pk]["capture_id"], self.before_capture.pk)
+        self.assertEqual(by_id[before.pk]["image_timestamp"], self.before_capture.timestamp.isoformat())
+        self.assertEqual(by_id[after.pk]["edge_image"], get_media_url(last.path))
+        self.assertEqual(by_id[after.pk]["edge_timestamp"], last.timestamp.isoformat())
+        self.assertEqual(by_id[after.pk]["capture_id"], self.after_capture.pk)
+        self.assertEqual(by_id[after.pk]["image_timestamp"], self.after_capture.timestamp.isoformat())
+
+    def test_a_gap_candidate_is_scored_against_the_track_frame_nearest_it(self):
+        """A candidate in a gap is paired with the track frame nearest it in time, not with the
+        first or last frame a minute or more away. The interior box sits across the frame from
+        the edge boxes, so a pairing with either edge would report a distance near 0.5."""
+        interior = self.detections[1]
+        interior.bbox = [500, 500, 530, 530]
+        interior.save(update_fields=["bbox"])
+        in_gap = self._make_occurrence(
+            [self._make_capture(interior.timestamp + datetime.timedelta(seconds=2))], bbox=[502, 502, 532, 532]
+        )
+
+        row = {row["id"]: row for row in self.get_candidates().data["candidates"]}[in_gap.pk]
+
+        self.assertEqual(row["edge_timestamp"], interior.timestamp.isoformat())
+        self.assertAlmostEqual(row["distance"], 0.002, delta=0.001)
+        geometry_only = total_cost(
+            None, None, [500, 500, 530, 530], [502, 502, 532, 532], image_diagonal(self.FRAME_SIZE, self.FRAME_SIZE)
+        )
+        self.assertAlmostEqual(row["cost"], geometry_only, places=4)
+
+    def test_minutes_must_be_a_whole_number_within_range(self):
+        for junk in ("abc", "0", "31", "-5"):
+            self.assertEqual(self.get_candidates(f"&minutes={junk}").status_code, 400, junk)
+        self.assertEqual(self.get_candidates("&minutes=30").status_code, 200)
+
+    def test_captures_and_minutes_are_validated(self):
+        """`captures` is a count within range, and it cannot be combined with `minutes`, since
+        each names a different search and the request would be ambiguous."""
+        for junk in ("abc", "0", "11"):
+            self.assertEqual(self.get_candidates(f"&captures={junk}").status_code, 400, junk)
+        response = self.get_candidates("&captures=1&minutes=5")
+        self.assertEqual(response.status_code, 400)
+        self.assertIn("minutes", response.data)
+        self.assertEqual(self.get_candidates("&captures=10").status_code, 200)
+
+    def test_candidates_are_gated_like_the_merge_itself(self):
+        self._make_occurrence([self.after_capture], bbox=[10, 10, 40, 40])
+
+        self.assertEqual(self.get_candidates(user=self.reader).status_code, 403)
+
+        self.client.force_authenticate(user=None)
+        anonymous = self.client.get(f"/api/v2/occurrences/{self.occurrence.pk}/merge-candidates/")
+        self.assertIn(anonymous.status_code, (401, 403))
+
+        self.assertEqual(self.get_candidates(user=self.curator).status_code, 200)
+
+    def test_track_edits_ignore_the_project_default_filters(self):
+        """Repairing a track reaches the occurrences that viewing hides.
+
+        The project's score threshold and excluded taxa say what is worth looking at,
+        which is a different question from which boxes are one animal, and an
+        occurrence a detector left undetermined belongs to a track like any other.
+        Viewing goes on hiding both.
+        """
+        self.project.default_filters_score_threshold = 0.9
+        self.project.save()
+        self.project.default_filters_exclude_taxa.set([self.taxon])
+
+        low_score = self._make_occurrence([self.after_capture], bbox=[12, 12, 42, 42], score=0.1)
+        undetermined = self._make_occurrence([self.before_capture], bbox=[14, 14, 44, 44], score=None)
+
+        offered = {row["id"]: row for row in self.get_candidates().data["candidates"]}
+        self.assertEqual(sorted(offered), sorted([low_score.pk, undetermined.pk]))
+        self.assertIsNone(offered[undetermined.pk]["determination"], "A candidate with no determination is offered")
+
+        listed = self.client.get(f"/api/v2/occurrences/?project_id={self.project.pk}")
+        self.assertEqual(listed.status_code, 200, listed.data)
+        visible = [row["id"] for row in listed.data["results"]]
+        self.assertNotIn(low_score.pk, visible, "A low-score occurrence stays hidden from the list")
+        self.assertNotIn(undetermined.pk, visible, "An undetermined occurrence stays hidden from the list")
+
+        merged = self.client.post(
+            f"/api/v2/occurrences/{self.occurrence.pk}/merge/",
+            {"occurrence_ids": [low_score.pk, undetermined.pk]},
+            format="json",
+        )
+        self.assertEqual(merged.status_code, 200, merged.data)
+        self.assertEqual(merged.data["detections_count"], len(self.detections) + 2)
+        self.assertFalse(Occurrence.objects.filter(pk__in=[low_score.pk, undetermined.pk]).exists())
+
+    def test_the_candidate_count_does_not_change_the_query_count(self):
+        extractor = Algorithm.objects.create(name="Feature extractor", key="feature-extractor")
+        vector = [1.0] + [0.0] * 2047
+        self._give_target_vectors(vector, extractor)
+        for offset in range(3):
+            self._make_occurrence(
+                [self.after_capture], bbox=[10 + offset, 10, 40 + offset, 40], vector=vector, algorithm=extractor
+            )
+
+        # The savepoint pair, the object lookup with its permission checks, then the
+        # seven ranking queries: the track's frames, the capture ids before and after
+        # it, the frames in those captures, the candidates, and the two vector sides.
+        with self.assertNumQueries(13):
+            response = self.get_candidates()
+
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual(len(response.data["candidates"]), 3)
+
+    def _stray_frame(self) -> Detection:
+        """The track's second frame, moved across the image so it reads as another animal's box."""
+        stray = self.detections[1]
+        stray.bbox = [300, 300, 330, 330]
+        stray.save(update_fields=["bbox"])
+        return stray
+
+    def test_a_detection_is_ranked_against_other_occurrences_from_its_own_box(self):
+        """Destinations for one frame are scored from that frame alone, so an occurrence on the
+        track's other captures is offered, and one on the frame's own capture is not."""
+        stray = self._stray_frame()
+        near = self._make_occurrence([self.captures[0], self.captures[2]], bbox=[302, 302, 332, 332])
+        far = self._make_occurrence([self.captures[2]], bbox=[700, 700, 730, 730])
+        same_capture = self._make_occurrence([self.captures[1]], bbox=[304, 304, 334, 334])
+
+        response = self.get_candidates(f"&detection={stray.pk}")
+        self.assertEqual(response.status_code, 200, response.data)
+
+        rows = response.data["candidates"]
+        self.assertEqual([row["id"] for row in rows], [near.pk, far.pk])
+        self.assertNotIn(same_capture.pk, [row["id"] for row in rows])
+        self.assertEqual((rows[0]["relation"], rows[0]["time_offset_seconds"]), ("gap", 0.0))
+        self.assertEqual((rows[1]["relation"], rows[1]["time_offset_seconds"]), ("after", 60.0))
+        self.assertEqual({row["edge_timestamp"] for row in rows}, {stray.timestamp.isoformat()})
+        whole_track = [row["id"] for row in self.get_candidates().data["candidates"]]
+        self.assertNotIn(near.pk, whole_track, "The whole track shares a capture with it")
+
+    def test_the_detection_must_be_one_of_the_occurrences_frames(self):
+        other = self._make_occurrence([self.after_capture], bbox=[10, 10, 40, 40])
+        foreign = other.detections.get()
+        for junk in ("abc", "0", str(foreign.pk)):
+            response = self.get_candidates(f"&detection={junk}")
+            self.assertEqual(response.status_code, 400, junk)
+            self.assertIn("detection", response.data)
+
+    def test_a_detection_ranking_has_a_fixed_query_count(self):
+        extractor = Algorithm.objects.create(name="Feature extractor", key="feature-extractor")
+        vector = [1.0] + [0.0] * 2047
+        self._give_target_vectors(vector, extractor)
+        stray = self._stray_frame()
+        for offset in range(3):
+            self._make_occurrence(
+                [self.captures[2]], bbox=[300 + offset, 300, 330 + offset, 330], vector=vector, algorithm=extractor
+            )
+
+        # Uncached: the savepoint pair, the object lookup with its identifications and
+        # permission checks, then the same seven ranking queries as for the whole track,
+        # the frame lookup doubling as the check that the detection is the occurrence's.
+        with cachalot_disabled(), self.assertNumQueries(15):
+            response = self.get_candidates(f"&detection={stray.pk}")
+
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertEqual(len(response.data["candidates"]), 3)
+        self.assertTrue(all(row["similarity"] == 1.0 for row in response.data["candidates"]))
+
+
+class CaptureMatchesTestCase(APITestCase):
+    """Previewing, box by box, what tracking would link on one capture of a track.
+
+    What these pin is that the preview comes from tracking's own matcher, run between every
+    box on the reference frame's capture and every box on the capture, so a box claimed by a
+    better match is not marked as linked; that a box without an embedding is marked skipped
+    while tracking requires them; that the reference is the track frame nearest in time on
+    another capture; and that the query count does not grow with the track or the capture.
+    """
+
+    FRAME_SIZE = 1000
+    VECTOR = [1.0] + [0.0] * 2047
+    TRACK_BOX = [10, 10, 40, 40]
+    # With equal vectors these cost about 0.12 and 0.22 from TRACK_BOX, either side of the
+    # tracker's default threshold of 0.2.
+    NEAR_BOX = [11, 11, 41, 41]
+    OFFSET_BOX = [12, 12, 42, 42]
+    FAR_BOX = [500, 500, 530, 530]
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        enable_tracking(self.project)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=6, interval_minutes=1)
+        SourceImage.objects.filter(deployment=self.deployment).update(width=self.FRAME_SIZE, height=self.FRAME_SIZE)
+        self.captures = list(SourceImage.objects.filter(deployment=self.deployment).order_by("timestamp"))
+        assert len(self.captures) >= 6, "Fixture must provide six consecutive captures"
+        self.event = self.captures[0].event
+        self.curator = User.objects.create_user(email="curator@insectai.org")  # type: ignore[attr-defined]
+        MLDataManager.assign_user(self.curator, self.project)
+        self.extractor = Algorithm.objects.create(name="Feature extractor", key="feature-extractor")
+        self.diagonal = image_diagonal(self.FRAME_SIZE, self.FRAME_SIZE)
+        self.threshold = TrackingConfig(event_ids=[self.event.pk]).cost_threshold
+
+    def _box(
+        self,
+        capture: SourceImage,
+        bbox: list[int],
+        occurrence: Occurrence | None = None,
+        vector: list[float] | None = None,
+        algorithm: Algorithm | None = None,
+    ) -> Detection:
+        detection = Detection.objects.create(
+            source_image=capture, timestamp=capture.timestamp, bbox=bbox, occurrence=occurrence
+        )
+        if vector is not None:
+            detection.classifications.create(
+                score=0.9, timestamp=capture.timestamp, algorithm=algorithm or self.extractor, features_2048=vector
+            )
+        return detection
+
+    def _track(self, captures: list[SourceImage], bbox: list[int] | None = None, vector=None) -> Occurrence:
+        occurrence = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+        for capture in captures:
+            self._box(capture, bbox or self.TRACK_BOX, occurrence=occurrence, vector=vector)
+        return occurrence
+
+    def _captures_after(self, count: int) -> list[SourceImage]:
+        last = self.captures[-1]
+        return [
+            SourceImage.objects.create(
+                deployment=self.deployment,
+                event=self.event,
+                timestamp=last.timestamp + datetime.timedelta(seconds=i + 1),
+                path=f"test/matches-{last.pk}-{i}.jpg",
+                width=self.FRAME_SIZE,
+                height=self.FRAME_SIZE,
+            )
+            for i in range(count)
+        ]
+
+    def get_matches(self, occurrence: Occurrence, capture_id, user: User | None = None):
+        self.client.force_authenticate(user=user or self.curator)
+        return self.client.get(
+            f"/api/v2/occurrences/{occurrence.pk}/capture-matches/"
+            f"?project_id={self.project.pk}&capture_id={capture_id}"
+        )
+
+    def test_the_box_tracking_would_link_is_marked(self):
+        """After the track's last frame, the box close enough to fall under the tracker's threshold
+        is the one it would link. One a little further off is scored but not linked, and its
+        likelihood, one minus the mean cost term, reads lower."""
+        track = self._track(self.captures[1:3], vector=self.VECTOR)
+        capture = self.captures[3]
+        neighbour = self._track([capture], bbox=self.NEAR_BOX, vector=self.VECTOR).detections.get()
+        offset = self._box(capture, self.OFFSET_BOX, vector=self.VECTOR)
+        loose = self._box(capture, self.FAR_BOX, vector=self.VECTOR)
+
+        response = self.get_matches(track, capture.pk)
+        self.assertEqual(response.status_code, 200, response.data)
+
+        data = response.data
+        self.assertEqual(data["cost_threshold"], self.threshold)
+        self.assertEqual(data["feature_algorithm_id"], self.extractor.pk)
+        self.assertTrue(data["requires_features"])
+        reference = track.detections.get(source_image=self.captures[2])
+        self.assertEqual(
+            (data["reference"]["detection_id"], data["reference"]["relation"], data["reference"]["skipped_reason"]),
+            (reference.pk, "after", None),
+        )
+        self.assertEqual([row["detection_id"] for row in data["detections"]], [neighbour.pk, offset.pk, loose.pk])
+
+        rows = {row["detection_id"]: row for row in data["detections"]}
+        self.assertEqual([rows[box.pk]["would_link"] for box in (neighbour, offset, loose)], [True, False, False])
+        self.assertIsNone(rows[loose.pk]["occurrence_id"])
+        for box in (neighbour, offset):
+            row = rows[box.pk]
+            cost = total_cost(self.VECTOR, self.VECTOR, self.TRACK_BOX, box.bbox, self.diagonal)
+            self.assertAlmostEqual(row["cost"], cost, places=4)
+            self.assertAlmostEqual(row["likelihood"], 1 - cost / 4, places=4)
+            self.assertAlmostEqual(row["iou"], iou(self.TRACK_BOX, box.bbox), places=4)
+            self.assertEqual((row["similarity"], row["size_ratio"], row["skipped_reason"]), (1.0, 1.0, None))
+            self.assertEqual(row["time_offset_seconds"], 60.0)
+        self.assertLess(rows[neighbour.pk]["cost"], self.threshold)
+        self.assertGreater(rows[offset.pk]["cost"], self.threshold)
+        self.assertGreater(rows[neighbour.pk]["likelihood"], rows[offset.pk]["likelihood"])
+        self.assertEqual(data["reference"]["capture_offset"], 1)
+
+    def test_on_a_capture_the_track_covers_its_own_box_keeps_the_link(self):
+        """The capture already holds the track's box, so the reference is the track frame one
+        capture earlier. Tracking would link that frame to the track's own box, which claims it
+        ahead of a neighbour that would otherwise have been linked."""
+        track = self._track(self.captures[1:4], vector=self.VECTOR)
+        capture = self.captures[3]
+        neighbour = self._box(capture, self.NEAR_BOX, vector=self.VECTOR)
+
+        data = self.get_matches(track, capture.pk).data
+
+        self.assertEqual(
+            (data["reference"]["relation"], data["reference"]["capture_id"]), ("same", self.captures[2].pk)
+        )
+        rows = {row["detection_id"]: row for row in data["detections"]}
+        own = rows[track.detections.get(source_image=capture).pk]
+        self.assertTrue(own["in_track"])
+        self.assertTrue(own["would_link"], "Tracking would keep the track's own link")
+        self.assertIsNone(own["likelihood"], "The track's own box is not a candidate")
+        self.assertFalse(rows[neighbour.pk]["would_link"])
+        self.assertGreater(rows[neighbour.pk]["likelihood"], 0.5)
+
+    def test_a_box_matched_better_by_another_box_is_not_linked(self):
+        """Tracking pairs every box on the two captures, so a box under the threshold from the
+        reference frame is still not linked to it when a box beside the reference matches it
+        better."""
+        track = self._track(self.captures[1:3], vector=self.VECTOR)
+        self._box(self.captures[2], self.NEAR_BOX, vector=self.VECTOR)
+        self._box(self.captures[3], self.NEAR_BOX, vector=self.VECTOR)
+
+        row = self.get_matches(track, self.captures[3].pk).data["detections"][0]
+
+        self.assertFalse(row["would_link"])
+        self.assertGreater(row["likelihood"], 0.5)
+
+    def test_the_preview_links_what_a_tracking_pass_saves(self):
+        """The preview and a tracking pass share one matcher, so on the same two captures the box
+        marked as linked is the one pair_detections links the reference frame to."""
+        track = self._track(self.captures[1:3], vector=self.VECTOR)
+        reference = track.detections.get(source_image=self.captures[2])
+        capture = self.captures[3]
+        self._box(self.captures[2], [14, 14, 44, 44], vector=self.VECTOR)
+        for bbox in (self.NEAR_BOX, [13, 13, 43, 43], self.FAR_BOX):
+            self._box(capture, bbox, vector=self.VECTOR)
+
+        rows = self.get_matches(track, capture.pk).data["detections"]
+        previewed = [row["detection_id"] for row in rows if row["would_link"]]
+
+        pair_detections(
+            list(self.captures[2].detections.valid()),
+            list(capture.detections.valid()),
+            image_width=self.FRAME_SIZE,
+            image_height=self.FRAME_SIZE,
+            cost_threshold=self.threshold,
+            algorithm=self.extractor,
+            logger=logging.getLogger(__name__),
+        )
+        reference.refresh_from_db()
+        self.assertIsNotNone(reference.next_detection_id, "The fixture must leave the reference frame a link")
+        self.assertEqual(previewed, [reference.next_detection_id])
+
+    def test_a_box_without_an_embedding_is_skipped_while_features_are_required(self):
+        """Tracking skips a box with no embedding when it requires them, so the box is marked and
+        not linked even though its geometry alone is under the threshold. Its cost is that
+        geometry alone."""
+        track = self._track(self.captures[1:3], vector=self.VECTOR)
+        self._box(self.captures[3], self.NEAR_BOX)
+
+        row = self.get_matches(track, self.captures[3].pk).data["detections"][0]
+
+        geometry = total_cost(None, None, self.TRACK_BOX, self.NEAR_BOX, self.diagonal)
+        self.assertLess(geometry, self.threshold)
+        self.assertEqual((row["skipped_reason"], row["would_link"], row["similarity"]), ("no_vector", False, None))
+        self.assertAlmostEqual(row["cost"], geometry, places=4)
+        self.assertAlmostEqual(row["likelihood"], 1 - geometry / 3, places=4)
+
+    def test_a_detector_only_session_links_nothing(self):
+        """With no embeddings at all, tracking has no extractor to compare and skips the captures
+        while it requires features, so every box and the reference frame are marked skipped."""
+        track = self._track(self.captures[1:3])
+        self._box(self.captures[3], self.NEAR_BOX)
+
+        data = self.get_matches(track, self.captures[3].pk).data
+
+        self.assertIsNone(data["feature_algorithm_id"])
+        self.assertEqual(data["reference"]["skipped_reason"], "no_vector")
+        row = data["detections"][0]
+        self.assertEqual((row["skipped_reason"], row["would_link"]), ("no_vector", False))
+        self.assertIsNotNone(row["cost"], "The geometry is still scored")
+
+    def test_two_feature_extractors_link_nothing(self):
+        """Embeddings from two extractors leave tracking no single one to compare, so it skips the
+        captures while it requires features, as it does a session with none."""
+        other_extractor = Algorithm.objects.create(name="Other extractor", key="other-extractor")
+        track = self._track(self.captures[1:3], vector=self.VECTOR)
+        self._box(self.captures[3], self.NEAR_BOX, vector=self.VECTOR, algorithm=other_extractor)
+
+        data = self.get_matches(track, self.captures[3].pk).data
+
+        self.assertIsNone(data["feature_algorithm_id"])
+        self.assertEqual(
+            (data["detections"][0]["skipped_reason"], data["detections"][0]["would_link"]), ("no_vector", False)
+        )
+
+    def test_the_reference_is_the_nearest_track_frame_on_another_capture(self):
+        """A track on the second and fifth of six captures a minute apart. Each capture is
+        scored against the nearer of the two, and the relation says where the capture lies;
+        on a capture holding a track frame the other frame is used."""
+        track = self._track([self.captures[1], self.captures[4]])
+        first, last = (track.detections.get(source_image=self.captures[i]).pk for i in (1, 4))
+        expected = {
+            0: ("before", first, -60.0),
+            2: ("gap", first, 60.0),
+            3: ("gap", last, -60.0),
+            5: ("after", last, 60.0),
+            1: ("same", last, -180.0),
+        }
+        for index, (relation, reference, offset) in expected.items():
+            self._box(self.captures[index], self.FAR_BOX)
+            data = self.get_matches(track, self.captures[index].pk).data
+            self.assertEqual((data["reference"]["relation"], data["reference"]["detection_id"]), (relation, reference))
+            candidate = next(row for row in data["detections"] if not row["in_track"])
+            self.assertEqual(candidate["time_offset_seconds"], offset, index)
+
+    def test_a_track_with_no_frame_on_another_capture_is_not_scored(self):
+        track = self._track([self.captures[0]])
+        other = self._box(self.captures[0], self.FAR_BOX)
+
+        data = self.get_matches(track, self.captures[0].pk).data
+
+        self.assertIsNone(data["reference"])
+        self.assertEqual({row["detection_id"] for row in data["detections"]}, {track.detections.get().pk, other.pk})
+        for row in data["detections"]:
+            self.assertIsNone(row["likelihood"])
+            self.assertFalse(row["would_link"])
+
+    def test_capture_id_must_name_a_capture_of_the_session(self):
+        track = self._track(self.captures[1:3])
+        for junk in ("abc", "", "0"):
+            self.assertEqual(self.get_matches(track, junk).status_code, 400, junk)
+        missing = self.client.get(f"/api/v2/occurrences/{track.pk}/capture-matches/?project_id={self.project.pk}")
+        self.assertEqual(missing.status_code, 400)
+
+        _, other_deployment = setup_test_project(reuse=False)
+        create_captures(deployment=other_deployment, num_nights=1, images_per_night=1)
+        other_project_capture = SourceImage.objects.filter(deployment=other_deployment).first()
+        ungrouped = SourceImage.objects.create(
+            deployment=self.deployment,
+            timestamp=self.captures[-1].timestamp + datetime.timedelta(days=2),
+            path="test/ungrouped.jpg",
+        )
+        for capture in (other_project_capture, ungrouped):
+            response = self.get_matches(track, capture.pk)
+            self.assertEqual(response.status_code, 400, response.data)
+            self.assertIn("capture_id", response.data)
+
+    def test_matches_are_gated_like_the_track_edits_they_lead_to(self):
+        """A member who cannot edit tracks is refused, and an outsider cannot learn that an
+        occurrence of a draft project exists."""
+        track = self._track(self.captures[1:3])
+        reader = User.objects.create_user(email="reader@insectai.org")  # type: ignore[attr-defined]
+        BasicMember.assign_user(reader, self.project)
+        self.assertEqual(self.get_matches(track, self.captures[3].pk, user=reader).status_code, 403)
+
+        self.project.draft = True
+        self.project.save()
+        outsider = User.objects.create_user(email="outsider@insectai.org")  # type: ignore[attr-defined]
+        self.assertEqual(self.get_matches(track, self.captures[3].pk, user=outsider).status_code, 404)
+        self.assertEqual(self.get_matches(track, self.captures[3].pk).status_code, 200)
+
+    def test_the_reference_says_how_many_captures_away_it_is(self):
+        """The offset counts captures from the reference frame's capture, signed, so a comparison
+        with a frame two captures later reads -2 rather than passing for the adjacent pairing."""
+        track = self._track(self.captures[3:5], vector=self.VECTOR)
+        self._box(self.captures[1], self.NEAR_BOX, vector=self.VECTOR)
+
+        reference = self.get_matches(track, self.captures[1].pk).data["reference"]
+
+        self.assertEqual(
+            (reference["capture_id"], reference["relation"], reference["capture_offset"]),
+            (self.captures[3].pk, "before", -2),
+        )
+
+    def test_the_query_count_does_not_grow_with_the_track_or_the_capture(self):
+        """Two boxes against a two-frame track, then twelve boxes against a thirty-frame one."""
+        short = self._track(self.captures[1:3], vector=self.VECTOR)
+        for offset in range(2):
+            self._box(self.captures[3], [10 + offset, 10, 40 + offset, 40], vector=self.VECTOR)
+        *long_frames, dense = self._captures_after(31)
+        long = self._track(long_frames, vector=self.VECTOR)
+        for offset in range(12):
+            self._box(dense, [10 + offset, 10, 40 + offset, 40], vector=self.VECTOR)
+
+        # The savepoint pair, the project, the object lookup with its identifications and
+        # permission checks, the capture, and six scoring queries: the reference frame, the
+        # boxes on both captures, their extractors, that extractor, its vectors, and the count
+        # of captures between the reference frame's capture and this one.
+        for occurrence, capture, boxes in ((short, self.captures[3], 2), (long, dense, 12)):
+            with cachalot_disabled(), self.assertNumQueries(14):
+                response = self.get_matches(occurrence, capture.pk)
+            self.assertEqual(response.status_code, 200, response.data)
+            self.assertEqual(len(response.data["detections"]), boxes)
+            self.assertTrue(all(row["similarity"] == 1.0 for row in response.data["detections"]))
+
+
+class TrackStatsTestCase(APITestCase):
+    """Track statistics the review interface sorts and filters by.
+
+    Four of them are stored on the occurrence row so the list can sort by them; the
+    detail recomputes all of them on read. What these pin is that the stored numbers
+    follow the documented definitions, that tracking and every track edit store them
+    for the occurrences they touch, that the list sorts by them at no extra cost per
+    page, and that the detail always describes the current detections.
+    """
+
+    FRAME_WIDTH = 300
+    FRAME_HEIGHT = 400  # a 300x400 frame has a diagonal of exactly 500
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_taxa(project=self.project)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=3, interval_minutes=1)
+        SourceImage.objects.filter(deployment=self.deployment).update(width=self.FRAME_WIDTH, height=self.FRAME_HEIGHT)
+        self.captures = list(SourceImage.objects.filter(deployment=self.deployment).order_by("timestamp"))
+        self.event = self.captures[0].event
+        self.project.default_filters_score_threshold = 0.0
+        self.project.save()
+
+        taxa = list(Taxon.objects.filter(projects=self.project).order_by("pk")[:3])
+        assert len(taxa) == 3, "Fixture must provide three taxa to disagree with"
+        self.taxon_a, self.taxon_b, self.taxon_c = taxa
+
+        self.reader = User.objects.create_user(email="track-stats-reader@insectai.org")  # type: ignore[attr-defined]
+        BasicMember.assign_user(self.reader, self.project)
+        self.client.force_authenticate(user=self.reader)
+
+        # Centres (5,5) -> (35,45) -> (65,85): two steps of 50 px over a 500 px diagonal.
+        # Areas 100, 100, 400. Terminal labels A, A, B plus a non-terminal C to ignore. C
+        # scores below every terminal label so it never becomes the determination when an
+        # edit saves the occurrence: predictions() keeps only each algorithm's top score.
+        self.track = self._make_occurrence(
+            [
+                ([0, 0, 10, 10], [(self.taxon_a, 0.9, True)]),
+                ([30, 40, 40, 50], [(self.taxon_a, 0.85, True)]),
+                ([55, 75, 75, 95], [(self.taxon_b, 0.8, True), (self.taxon_c, 0.5, False)]),
+            ],
+            link=True,
+        )
+        self.singleton = self._make_occurrence([([10, 10, 20, 20], [(self.taxon_a, 0.7, True)])])
+        # Centres (115,110) -> (145,150): one step of 50 px, so its motion of 0.1 sits
+        # between the track's 0.2 and the singleton's 0.0 for the ordering tests.
+        self.other_track = self._make_occurrence(
+            [
+                ([100, 100, 130, 120], [(self.taxon_b, 0.6, True)]),
+                ([130, 140, 160, 160], [(self.taxon_b, 0.6, True)]),
+            ]
+        )
+        return super().setUp()
+
+    def _make_occurrence(
+        self, frames: list[tuple[list[int], list[tuple[Taxon, float, bool]]]], link=False, store=True
+    ) -> Occurrence:
+        from ami.main.models_future.track_stats import refresh_track_stats
+
+        occurrence = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+        detections = []
+        for capture, (bbox, labels) in zip(self.captures, frames):
+            detection = Detection.objects.create(
+                source_image=capture, timestamp=capture.timestamp, bbox=bbox, occurrence=occurrence
+            )
+            for taxon, score, terminal in labels:
+                detection.classifications.create(
+                    taxon=taxon, score=score, timestamp=capture.timestamp, terminal=terminal
+                )
+            detections.append(detection)
+        if link:
+            for earlier, later in zip(detections, detections[1:]):
+                earlier.next_detection = later
+                earlier.save(update_fields=["next_detection"])
+        occurrence.save()
+        # Pin the determination the agreement is measured against, independent of how
+        # save() picks one.
+        Occurrence.objects.filter(pk=occurrence.pk).update(determination=self.taxon_a, determination_score=0.9)
+        if store:
+            refresh_track_stats(occurrence)
+        return occurrence
+
+    def _stored(self, occurrence: Occurrence) -> dict:
+        """The four stored fields as the database holds them now."""
+        from ami.main.models_future.track_stats import TRACK_STAT_FIELDS
+
+        return Occurrence.objects.filter(pk=occurrence.pk).values(*TRACK_STAT_FIELDS).get()
+
+    def _list_url(self, **params) -> str:
+        query = "".join(f"&{key}={value}" for key, value in params.items())
+        return f"/api/v2/occurrences/?project_id={self.project.pk}&limit=20{query}"
+
+    def _list_rows(self, **params) -> dict[int, dict]:
+        response = self.client.get(self._list_url(**params))
+        self.assertEqual(response.status_code, 200, response.data)
+        return {row["id"]: row for row in response.data["results"]}
+
+    def _list_order(self, ordering: str) -> list[int]:
+        response = self.client.get(self._list_url(ordering=ordering))
+        self.assertEqual(response.status_code, 200, response.data)
+        return [row["id"] for row in response.data["results"]]
+
+    def test_stored_stats_follow_the_documented_definitions(self):
+        rows = self._list_rows()
+
+        stats = rows[self.track.pk]["track_stats"]
+        self.assertEqual(set(stats), {"frames", "motion", "size_ratio", "distinct_taxa", "id_agreement"})
+        self.assertEqual(stats["frames"], 3)
+        self.assertAlmostEqual(stats["motion"], 100 / 500, places=4)
+        self.assertAlmostEqual(stats["size_ratio"], 4.0, places=4)
+        self.assertEqual(stats["distinct_taxa"], 2, "A non-terminal classification must not count as a taxon")
+        self.assertAlmostEqual(stats["id_agreement"], 2 / 3, places=4)
+
+        self.assertEqual(
+            rows[self.singleton.pk]["track_stats"],
+            {"frames": 1, "motion": 0.0, "size_ratio": 1.0, "distinct_taxa": 1, "id_agreement": 1.0},
+        )
+
+    def test_stats_are_null_until_something_stores_them(self):
+        unstored = self._make_occurrence([([50, 50, 60, 60], [(self.taxon_a, 0.5, True)])], store=False)
+        self.assertEqual(set(self._stored(unstored).values()), {None})
+        self.assertIsNone(self._list_rows()[unstored.pk]["track_stats"])
+
+    def _list_query_count(self, stats_stored: bool) -> int:
+        # Inside a test transaction cachalot answers repeat queries from a per-transaction
+        # layer that clearing the cache backend does not reach, so measure with it off.
+        with cachalot_disabled(), CaptureQueriesContext(connection) as ctx:
+            rows = self._list_rows()
+        self.assertEqual(len(rows), 3, "A one-row page cannot show a per-row cost")
+        self.assertTrue(all((row["track_stats"] is not None) is stats_stored for row in rows.values()))
+        return len(ctx.captured_queries)
+
+    def test_stored_stats_add_no_query_to_a_page(self):
+        """The stats are columns on the rows a page already reads, so the page costs the
+        same whether they are stored or still null. Measured against the same page with
+        the stats cleared, so the list's own per-row cost does not decide the outcome.
+        """
+        from ami.main.models_future.track_stats import TRACK_STAT_FIELDS
+
+        self._list_rows()  # warm process-level caches so both measurements start equal
+        with_stats = self._list_query_count(stats_stored=True)
+        Occurrence.objects.filter(project=self.project).update(**{field: None for field in TRACK_STAT_FIELDS})
+        without = self._list_query_count(stats_stored=False)
+        self.assertEqual(with_stats, without)
+
+    def test_the_list_sorts_by_the_stored_stats_with_unstored_rows_last(self):
+        unstored = self._make_occurrence([([50, 50, 60, 60], [(self.taxon_a, 0.5, True)])], store=False)
+
+        self.assertEqual(
+            self._list_order("-track_motion"),
+            [self.track.pk, self.other_track.pk, self.singleton.pk, unstored.pk],
+        )
+        self.assertEqual(
+            self._list_order("track_motion"),
+            [self.singleton.pk, self.other_track.pk, self.track.pk, unstored.pk],
+        )
+        # The other three are accepted too: an unknown ordering field is silently ignored
+        # by the filter backend, which would leave the default order in place.
+        self.assertEqual(
+            self._list_order("-track_id_agreement"),
+            [self.singleton.pk, self.track.pk, self.other_track.pk, unstored.pk],
+        )
+        for field in ("-track_size_ratio", "-track_distinct_taxa"):
+            order = self._list_order(field)
+            self.assertEqual(order[0], self.track.pk, field)
+            self.assertEqual(order[-1], unstored.pk, field)
+
+    def test_splitting_stores_stats_for_both_halves(self):
+        from ami.main.models_future.tracks import split_track
+
+        frames = list(self.track.detections.order_by("timestamp", "pk"))
+        tail = split_track(self.track, frames[1])
+
+        self.assertEqual(
+            self._stored(self.track),
+            {"track_motion": 0.0, "track_size_ratio": 1.0, "track_distinct_taxa": 1, "track_id_agreement": 1.0},
+        )
+        # The tail's determination is its best terminal prediction, A at 0.85, so one of
+        # its two terminal labels agrees.
+        self.assertEqual(
+            self._stored(tail),
+            {"track_motion": 0.1, "track_size_ratio": 4.0, "track_distinct_taxa": 2, "track_id_agreement": 0.5},
+        )
+        self.assertEqual(tail.track_motion, 0.1, "The instance the edit returns carries the stored numbers")
+
+    def test_detaching_a_frame_stores_stats_for_both_occurrences(self):
+        from ami.main.models_future.tracks import detach_detection
+
+        frames = list(self.track.detections.order_by("timestamp", "pk"))
+        detached = detach_detection(self.track, frames[1])
+
+        # (5,5) -> (65,85) is one step of 100 px; areas 100 and 400; labels A and B.
+        self.assertEqual(
+            self._stored(self.track),
+            {"track_motion": 0.2, "track_size_ratio": 4.0, "track_distinct_taxa": 2, "track_id_agreement": 0.5},
+        )
+        self.assertEqual(
+            self._stored(detached),
+            {"track_motion": 0.0, "track_size_ratio": 1.0, "track_distinct_taxa": 1, "track_id_agreement": 1.0},
+        )
+
+    def test_merging_stores_stats_for_the_survivor(self):
+        import math
+
+        from ami.main.models_future.tracks import merge_occurrences
+
+        # One animal appears once per capture, so the frame merged in sits on a capture
+        # after the track's last: (5,5) -> (35,45) -> (65,85) -> (15,15). Labels A, A, B, A.
+        later = SourceImage.objects.create(
+            deployment=self.deployment,
+            event=self.event,
+            timestamp=self.captures[-1].timestamp + datetime.timedelta(minutes=1),
+            path="test/track-stats-later.jpg",
+            width=self.FRAME_WIDTH,
+            height=self.FRAME_HEIGHT,
+        )
+        later_singleton = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+        frame = Detection.objects.create(
+            source_image=later, timestamp=later.timestamp, bbox=[10, 10, 20, 20], occurrence=later_singleton
+        )
+        frame.classifications.create(taxon=self.taxon_a, score=0.7, timestamp=later.timestamp, terminal=True)
+        later_singleton.save()
+
+        merge_occurrences(self.track, [later_singleton])
+
+        stored = self._stored(self.track)
+        self.assertAlmostEqual(stored["track_motion"], (50 + 50 + math.hypot(50, 70)) / 500, places=4)
+        self.assertEqual(stored["track_size_ratio"], 4.0)
+        self.assertEqual(stored["track_distinct_taxa"], 2)
+        self.assertEqual(stored["track_id_agreement"], 0.75)
+
+    def test_adding_a_detection_stores_stats_for_donor_and_recipient(self):
+        import math
+
+        from ami.main.models_future.tracks import add_detections
+
+        moved = self.other_track.detections.order_by("timestamp", "pk").last()
+        add_detections(self.singleton, [moved])
+
+        # Recipient: (15,15) -> (145,150), areas 100 and 600, labels A and B with A kept.
+        stored = self._stored(self.singleton)
+        self.assertAlmostEqual(stored["track_motion"], math.hypot(130, 135) / 500, places=4)
+        self.assertEqual(stored["track_size_ratio"], 6.0)
+        self.assertEqual(stored["track_distinct_taxa"], 2)
+        self.assertEqual(stored["track_id_agreement"], 0.5)
+        # Donor: one frame left, and its determination settles on that frame's label.
+        self.assertEqual(
+            self._stored(self.other_track),
+            {"track_motion": 0.0, "track_size_ratio": 1.0, "track_distinct_taxa": 1, "track_id_agreement": 1.0},
+        )
+
+    def test_the_backfill_command_stores_stats_for_multi_frame_occurrences(self):
+        from io import StringIO
+
+        from django.core.management import call_command
+
+        from ami.main.models_future.track_stats import TRACK_STAT_FIELDS
+
+        Occurrence.objects.filter(project=self.project).update(**{field: None for field in TRACK_STAT_FIELDS})
+
+        out = StringIO()
+        call_command("backfill_track_stats", project=self.project.pk, stdout=out)
+        self.assertIn("2 multi-frame occurrences", out.getvalue())
+        self.assertEqual(self._stored(self.track)["track_motion"], 0.2)
+        self.assertEqual(self._stored(self.other_track)["track_motion"], 0.1)
+        self.assertIsNone(self._stored(self.singleton)["track_motion"], "Single frames are skipped by default")
+
+        call_command("backfill_track_stats", project=self.project.pk, only_multi_frame=False, stdout=out)
+        self.assertEqual(self._stored(self.singleton)["track_motion"], 0.0)
+
+    def test_the_backfill_command_refuses_an_unknown_project(self):
+        from django.core.management import CommandError, call_command
+
+        with self.assertRaises(CommandError):
+            call_command("backfill_track_stats", project=0)
+
+    def test_detail_summarises_the_grouping_from_the_current_detections(self):
+        response = self.client.get(f"/api/v2/occurrences/{self.track.pk}/")
+        self.assertEqual(response.status_code, 200, response.data)
+        self.assertNotIn("track_stats", response.data, "The stored stats belong to the list")
+
+        summary = response.data["grouping_summary"]
+        self.assertIs(summary["derived"], True)
+        self.assertIsNone(summary["algorithm"], "No tracking run has registered an algorithm here")
+        self.assertEqual(summary["frames"], 3)
+        self.assertEqual(summary["linked_detections"], 2)
+        self.assertAlmostEqual(summary["duration_seconds"], 120.0)
+        self.assertAlmostEqual(summary["motion"], 100 / 500, places=4)
+        self.assertAlmostEqual(summary["size_ratio"], 4.0, places=4)
+        self.assertEqual(summary["distinct_taxa"], 2)
+        self.assertAlmostEqual(summary["id_agreement"], 2 / 3, places=4)
+        self.assertAlmostEqual(summary["score_min"], 0.8, places=4)
+        self.assertAlmostEqual(summary["score_mean"], 0.85, places=4)
+        self.assertAlmostEqual(summary["score_max"], 0.9, places=4)
+
+    def test_detail_names_the_tracking_algorithm_once_it_exists(self):
+        from ami.ml.models.algorithm import Algorithm
+        from ami.ml.post_processing.tracking_task import TrackingTask
+
+        algorithm = Algorithm.objects.create(key=TrackingTask.key, name=TrackingTask.name)
+        response = self.client.get(f"/api/v2/occurrences/{self.track.pk}/")
+        self.assertEqual(
+            response.data["grouping_summary"]["algorithm"],
+            {"id": algorithm.pk, "name": TrackingTask.name, "key": TrackingTask.key},
+        )
+
+    def test_detail_summary_reads_only_what_is_already_prefetched(self):
+        """The summary adds no query per frame or per classification: one lookup for the algorithm, then none."""
+        from ami.main.models_future.track_stats import grouping_summary_from_prefetch, tracking_algorithm_summary
+
+        occurrence = Occurrence.objects.filter(pk=self.track.pk).with_detail_prefetches().get()
+        with cachalot_disabled(), self.assertNumQueries(1):
+            algorithm = tracking_algorithm_summary()
+        with cachalot_disabled(), self.assertNumQueries(0):
+            summary = grouping_summary_from_prefetch(occurrence, algorithm)
+        self.assertEqual(summary["frames"], 3)
+
+
+class FeatureVectorPresenceTestCase(APITestCase):
+    """Whether a feature embedding was stored, told without ever loading the embedding.
+
+    Tracking and merge ranking read the vectors; the review interface only needs to
+    know they exist. These pin that the flag and the two counts come from SQL, that the
+    2048-float column is only ever tested for NULL by the detail endpoints, and that
+    reporting them adds no query.
+    """
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_taxa(project=self.project)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=3, interval_minutes=1)
+        self.captures = list(SourceImage.objects.filter(deployment=self.deployment).order_by("timestamp"))
+        self.event = self.captures[0].event
+        self.project.default_filters_score_threshold = 0.0
+        self.project.save()
+
+        taxon = Taxon.objects.filter(projects=self.project).first()
+        assert taxon is not None, "Fixture must provide a taxon to classify with"
+        self.taxon = taxon
+        self.vector = [0.5] * 2048
+
+        self.reader = User.objects.create_user(email="features-reader@insectai.org")  # type: ignore[attr-defined]
+        BasicMember.assign_user(self.reader, self.project)
+        self.client.force_authenticate(user=self.reader)
+        return super().setUp()
+
+    def _make_occurrence(self, frames: list[bool]) -> Occurrence:
+        """One detection per frame, in capture order; True stores a vector on its classification."""
+        occurrence = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+        for capture, with_vector in zip(self.captures, frames):
+            detection = Detection.objects.create(
+                source_image=capture, timestamp=capture.timestamp, bbox=[10, 10, 40, 40], occurrence=occurrence
+            )
+            detection.classifications.create(
+                taxon=self.taxon,
+                score=0.9,
+                timestamp=capture.timestamp,
+                features_2048=self.vector if with_vector else None,
+            )
+        occurrence.save()
+        return occurrence
+
+    def _get(self, url: str) -> tuple[typing.Any, list[dict]]:
+        from cachalot.api import cachalot_disabled
+
+        with cachalot_disabled(), CaptureQueriesContext(connection) as ctx:
+            response = self.client.get(url)
+        self.assertEqual(response.status_code, 200, response.data)
+        return response, ctx.captured_queries
+
+    @staticmethod
+    def _reads_the_vector(queries: list[dict]) -> bool:
+        """True if any query touches the embedding column other than to test it for NULL."""
+        sql = "\n".join(query["sql"] for query in queries)
+        return re.search(r'"features_2048"(?! IS NOT NULL)', sql) is not None
+
+    def _occurrence_url(self, occurrence: Occurrence) -> str:
+        return f"/api/v2/occurrences/{occurrence.pk}/?project_id={self.project.pk}"
+
+    def test_occurrence_detail_says_which_classifications_stored_a_vector(self):
+        occurrence = self._make_occurrence([True, False])
+        response, queries = self._get(self._occurrence_url(occurrence))
+
+        by_capture = {
+            detection["capture"]["id"]: [c["has_features"] for c in detection["classifications"]]
+            for detection in response.data["detections"]
+        }
+        self.assertEqual(by_capture, {self.captures[0].pk: [True], self.captures[1].pk: [False]})
+        self.assertCountEqual([p["has_features"] for p in response.data["predictions"]], [True, False])
+        self.assertNotIn("features_2048", response.data["detections"][0]["classifications"][0])
+        self.assertFalse(self._reads_the_vector(queries), "The embedding must never be selected")
+
+    def test_the_flag_costs_no_query(self):
+        """The same detail request runs the same queries whether or not vectors are stored."""
+        from cachalot.api import cachalot_disabled
+
+        occurrence = self._make_occurrence([False, False, False])
+        url = self._occurrence_url(occurrence)
+        self.client.get(url)  # warm up auth and pool state
+        _, without_vectors = self._get(url)
+
+        Classification.objects.filter(detection__occurrence=occurrence).update(features_2048=self.vector)
+        with cachalot_disabled(), self.assertNumQueries(len(without_vectors)) as ctx:
+            response = self.client.get(url)
+        self.assertEqual(
+            [c["has_features"] for d in response.data["detections"] for c in d["classifications"]],
+            [True, True, True],
+        )
+        self.assertFalse(self._reads_the_vector(ctx.captured_queries))
+
+    def test_grouping_summary_counts_the_frames_with_a_vector(self):
+        occurrence = self._make_occurrence([True, True, False])
+        response, _ = self._get(self._occurrence_url(occurrence))
+        self.assertEqual(response.data["grouping_summary"]["frames"], 3)
+        self.assertEqual(response.data["grouping_summary"]["frames_with_vectors"], 2)
+
+    def test_grouping_summary_refuses_an_occurrence_without_the_count(self):
+        """The count comes from the detail queryset; it is never guessed as zero."""
+        from ami.main.models_future.occurrence import prefetch_detections_for_detail
+        from ami.main.models_future.track_stats import grouping_summary_from_prefetch
+
+        occurrence = self._make_occurrence([True])
+        loaded = Occurrence.objects.filter(pk=occurrence.pk).prefetch_related(prefetch_detections_for_detail()).get()
+        with self.assertRaises(RuntimeError):
+            grouping_summary_from_prefetch(loaded, None)
+
+    def test_detection_detail_says_whether_its_classifications_stored_a_vector(self):
+        occurrence = self._make_occurrence([True])
+        detection = occurrence.detections.get()
+        response, queries = self._get(f"/api/v2/detections/{detection.pk}/?project_id={self.project.pk}")
+        self.assertEqual([c["has_features"] for c in response.data["classifications"]], [True])
+        self.assertFalse(self._reads_the_vector(queries))
+
+    def test_capture_detail_counts_the_detections_with_a_vector(self):
+        """A detection counts once however many of its classifications stored a vector,
+        and a null marker never counts."""
+        capture = self.captures[0]
+        occurrence = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+
+        def make_detection(vectors: list[bool], bbox: list[int] | None = [10, 10, 40, 40]) -> None:
+            detection = Detection.objects.create(
+                source_image=capture, timestamp=capture.timestamp, bbox=bbox, occurrence=occurrence
+            )
+            for with_vector in vectors:
+                detection.classifications.create(
+                    taxon=self.taxon,
+                    score=0.9,
+                    timestamp=capture.timestamp,
+                    features_2048=self.vector if with_vector else None,
+                )
+
+        make_detection([True])
+        make_detection([True, True])
+        make_detection([False])
+        make_detection([])
+        make_detection([True], bbox=None)
+        occurrence.save()
+
+        response, queries = self._get(f"/api/v2/captures/{capture.pk}/?project_id={self.project.pk}")
+        self.assertEqual(response.data["detections_with_features"], 2)
+        self.assertEqual(response.data["detections_valid"], 4, "The total the count is out of skips the marker")
+        self.assertFalse(self._reads_the_vector(queries))
+
+        listed, _ = self._get(f"/api/v2/captures/?project_id={self.project.pk}")
+        self.assertNotIn("detections_with_features", listed.data["results"][0], "Counted on the detail only")
+
+    def test_the_capture_counts_ride_on_the_capture_row(self):
+        """Both counts are subqueries on the capture's own SELECT: five detections, one query."""
+        from cachalot.api import cachalot_disabled
+
+        capture = self.captures[0]
+        occurrence = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+        for with_vector in [True, False, True, False, True]:
+            detection = Detection.objects.create(
+                source_image=capture, timestamp=capture.timestamp, bbox=[10, 10, 40, 40], occurrence=occurrence
+            )
+            detection.classifications.create(
+                taxon=self.taxon,
+                score=0.9,
+                timestamp=capture.timestamp,
+                features_2048=self.vector if with_vector else None,
+            )
+
+        with cachalot_disabled(), self.assertNumQueries(1):
+            annotated = SourceImage.objects.filter(pk=capture.pk).with_detections_with_features().get()
+            self.assertEqual(annotated.detections_valid, 5)  # type: ignore[attr-defined]
+            self.assertEqual(annotated.detections_with_features, 3)  # type: ignore[attr-defined]
diff --git a/ami/ml/models/pipeline.py b/ami/ml/models/pipeline.py
index 8ebaf6d6d..be739d84d 100644
--- a/ami/ml/models/pipeline.py
+++ b/ami/ml/models/pipeline.py
@@ -15,6 +15,7 @@
 import uuid
 from urllib.parse import urljoin
 
+import pydantic
 import requests
 from django.db import models
 from django.utils.text import slugify
@@ -344,7 +345,7 @@ def process_images(
     # Check if feature flag is enabled to reprocess existing detections
     if project and project.feature_flags.reprocess_existing_detections:
         # Check if the user wants to reprocess existing detections or ignore them
-        if pipeline_config.get("reprocess_existing_detections", True):
+        if pipeline_config.reprocess_existing_detections:
             reprocess_existing_detections = True
 
     for source_image, url in zip(images, urls):
@@ -807,7 +808,7 @@ def create_classification(
 
     if existing_classification:
         # @TODO remove this after all existing classifications have been updated (added 2024-12-20)
-        NEW_FIELDS = ["logits", "scores", "terminal", "category_map"]
+        NEW_FIELDS = ["logits", "scores", "terminal", "category_map", "features_2048"]
         logger.debug(
             "Duplicate classification found: "
             f"{existing_classification.taxon} from {existing_classification.algorithm}, "
@@ -824,6 +825,9 @@ def create_classification(
                 if field == "category_map":
                     # Use the foreign key from the classification algorithm
                     setattr(existing_classification, field, classification_algo.category_map)
+                elif field == "features_2048":
+                    # The pipeline response carries this as `features`; the DB column is `features_2048`.
+                    setattr(existing_classification, field, classification_resp.features)
                 else:
                     # Get the value from the classification response
                     setattr(existing_classification, field, getattr(classification_resp, field))
@@ -841,6 +845,7 @@ def create_classification(
             timestamp=classification_resp.timestamp or now(),
             logits=classification_resp.logits,
             scores=classification_resp.scores,
+            features_2048=classification_resp.features,
             terminal=classification_resp.terminal,
             category_map=classification_algo.category_map,
         )
@@ -1237,21 +1242,25 @@ def get_config(self, project_id: int | None = None) -> PipelineRequestConfigPara
         """
         Get the configuration for the pipeline request.
 
-        This will be the same as pipeline.default_config, but if a project ID is provided,
-        the project's pipeline config will be used to override the default config.
+        Schema defaults apply first, then pipeline.default_config, then the project's
+        pipeline config when a project ID is provided. Each call builds a new object,
+        so one project's overrides never reach the pipeline default or another project.
+        Invalid values raise a pydantic ValidationError.
         """
-        config = self.default_config
+        default_config = self.default_config
+        if isinstance(default_config, pydantic.BaseModel):
+            default_config = default_config.dict()
+        values = dict(default_config or {})
         if project_id:
             try:
                 project_pipeline_config = self.project_pipeline_configs.get(project_id=project_id)
-                if project_pipeline_config.config:
-                    config.update(project_pipeline_config.config)
+                values.update(project_pipeline_config.config or {})
                 logger.debug(
-                    f"Using ProjectPipelineConfig for Pipeline {self} and Project #{project_id}:" f"config: {config}"
+                    f"Using ProjectPipelineConfig for Pipeline {self} and Project #{project_id}:" f"config: {values}"
                 )
             except self.project_pipeline_configs.model.DoesNotExist as e:
                 logger.warning(f"No project-pipeline config for Pipeline {self} " f"and Project #{project_id}: {e}")
-        return config
+        return PipelineRequestConfigParameters.parse_obj(values)
 
     def collect_images(
         self,
diff --git a/ami/ml/post_processing/__init__.py b/ami/ml/post_processing/__init__.py
index c94be9ae9..b3d514068 100644
--- a/ami/ml/post_processing/__init__.py
+++ b/ami/ml/post_processing/__init__.py
@@ -1,2 +1,2 @@
-from . import class_masking  # noqa: F401
-from . import small_size_filter  # noqa: F401
+# Tasks are registered in registry.py. Nothing is imported here, so modules without Django
+# dependencies (tracking_evaluation) can run as `python -m` outside Antenna.
diff --git a/ami/ml/post_processing/admin/forms.py b/ami/ml/post_processing/admin/forms.py
index c9c162808..ebf97ce4d 100644
--- a/ami/ml/post_processing/admin/forms.py
+++ b/ami/ml/post_processing/admin/forms.py
@@ -28,6 +28,8 @@ def __init__(self, *args, scope_queryset=None, **kwargs):
         their fields to that selection; forms that don't need it ignore it.
         """
         self.scope_queryset = scope_queryset
+        # Shown above the form on the confirmation page when set.
+        self.notice: str | None = None
         super().__init__(*args, **kwargs)
 
     def to_config(self) -> dict:
diff --git a/ami/ml/post_processing/admin/tracking_actions.py b/ami/ml/post_processing/admin/tracking_actions.py
new file mode 100644
index 000000000..3a6eb339a
--- /dev/null
+++ b/ami/ml/post_processing/admin/tracking_actions.py
@@ -0,0 +1,63 @@
+"""Job builder for the Events entry point to Occurrence Tracking.
+
+Tracking runs per session, and the Events changelist lets an operator pick
+sessions from several projects at once. A Job belongs to exactly one project, so
+the selection is partitioned by project: one Job per project, carrying that
+project's event ids.
+"""
+from __future__ import annotations
+
+import collections
+from typing import Any
+
+import pydantic
+from django.db import transaction
+
+from ami.jobs.models import Job
+from ami.ml.post_processing.admin.actions import ConfigValidationErrors
+from ami.ml.post_processing.base import BasePostProcessingTask
+
+
+def build_tracking_jobs_for_events(
+    *,
+    config: dict[str, Any],
+    queryset,
+    task_cls: type[BasePostProcessingTask],
+    form_field_names: set[str],
+    **_unused: Any,
+) -> list[int]:
+    """Enqueue one tracking Job per project across the selected events."""
+    events_by_project: dict[Any, list[int]] = collections.defaultdict(list)
+    orphans: list[int] = []
+    for event in queryset:
+        if event.project_id is None:
+            orphans.append(event.pk)
+        else:
+            events_by_project[event.project_id].append(event.pk)
+
+    errors: list[tuple[str | None, str]] = []
+    if orphans:
+        errors.append((None, f"Session(s) {sorted(orphans)} have no project. Set their project first."))
+
+    validated: list[tuple[int, pydantic.BaseModel]] = []
+    for project_id, event_ids in events_by_project.items():
+        try:
+            validated.append((project_id, task_cls.config_schema(**{**config, "event_ids": sorted(event_ids)})))
+        except pydantic.ValidationError as exc:
+            errors.extend((None, err.get("msg", "Invalid value")) for err in exc.errors())
+
+    if errors:
+        raise ConfigValidationErrors(errors)
+
+    job_pks: list[int] = []
+    with transaction.atomic():
+        for project_id, model in validated:
+            job = Job.objects.create(
+                name=f"Post-processing: {task_cls.name} on {len(model.event_ids)} session(s)",
+                project_id=project_id,
+                job_type_key="post_processing",
+                params={"task": task_cls.key, "config": model.dict()},
+            )
+            job.enqueue()
+            job_pks.append(job.pk)
+    return job_pks
diff --git a/ami/ml/post_processing/admin/tracking_form.py b/ami/ml/post_processing/admin/tracking_form.py
new file mode 100644
index 000000000..214731a72
--- /dev/null
+++ b/ami/ml/post_processing/admin/tracking_form.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from django import forms
+
+from ami.main.models import Project
+from ami.ml.models import Algorithm
+from ami.ml.models.algorithm import AlgorithmTaskType
+from ami.ml.post_processing.admin.forms import BasePostProcessingActionForm
+
+
+class TrackingActionForm(BasePostProcessingActionForm):
+    """Knobs surfaced when an admin triggers Occurrence Tracking.
+
+    The scope (which capture set or events to track) comes from the admin entry
+    point, not the form. Everything here tunes how detections are matched.
+    """
+
+    cost_threshold = forms.FloatField(
+        initial=0.2,
+        min_value=0.0,
+        label="Matching cost threshold",
+        help_text=(
+            "Two detections in consecutive captures are linked when their matching cost "
+            "falls below this. Cost rises with appearance difference, distance moved and "
+            "change in box size, so a higher threshold links more detections and risks "
+            "merging different insects. Without embeddings, start around 0.5."
+        ),
+    )
+    require_features = forms.BooleanField(
+        required=False,
+        initial=True,
+        label="Require feature embeddings",
+        help_text=(
+            "Only match detections that carry a model embedding. Turn this off to track "
+            "captures processed before embeddings were stored; matching then uses bounding-box "
+            "position and size alone, which is more permissive."
+        ),
+    )
+    feature_extraction_algorithm_id = forms.ModelChoiceField(
+        queryset=Algorithm.objects.filter(task_type=AlgorithmTaskType.CLASSIFICATION.value).order_by("name"),
+        required=False,
+        label="Feature extractor",
+        help_text=(
+            "Whose embeddings to compare. Leave blank to detect it automatically; set it when "
+            "more than one classifier has run on the same session."
+        ),
+    )
+    skip_if_human_identifications = forms.BooleanField(
+        required=False,
+        initial=True,
+        label="Skip sessions with human identifications",
+        help_text="Protects reviewed sessions: merging occurrences there would discard identifications.",
+    )
+    require_fresh_event = forms.BooleanField(
+        required=False,
+        initial=True,
+        label="Only track untracked sessions",
+        help_text=(
+            "Skip sessions whose detections have already been grouped. Re-tracking grouped "
+            "data is not supported yet, so leaving this on is the safe choice."
+        ),
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Staff can run tracking on any project; the note keeps them from assuming
+        # its members can then review the result.
+        if self.scope_queryset is not None:
+            projects = Project.objects.filter(pk__in=self.scope_queryset.values("project_id")).order_by("name")
+            disabled = [project.name for project in projects if not project.feature_flags.tracking]
+            if disabled:
+                self.notice = (
+                    f"Tracking is not enabled for {', '.join(disabled)}. The run will go ahead, "
+                    "but members of those projects cannot edit or confirm tracks until the "
+                    "project's tracking flag is turned on."
+                )
+
+    def to_config(self) -> dict:
+        algorithm = self.cleaned_data["feature_extraction_algorithm_id"]
+        return {
+            "cost_threshold": self.cleaned_data["cost_threshold"],
+            "require_features": self.cleaned_data["require_features"],
+            "feature_extraction_algorithm_id": algorithm.pk if algorithm else None,
+            "skip_if_human_identifications": self.cleaned_data["skip_if_human_identifications"],
+            "require_fresh_event": self.cleaned_data["require_fresh_event"],
+        }
diff --git a/ami/ml/post_processing/admin_forms.py b/ami/ml/post_processing/admin_forms.py
new file mode 100644
index 000000000..41bac52b3
--- /dev/null
+++ b/ami/ml/post_processing/admin_forms.py
@@ -0,0 +1,117 @@
+"""Forms for triggering post-processing tasks from the Django admin.
+
+Each form is the single source of truth for the human-readable labels,
+help-text, and validation rules of one task's tunable parameters. The form's
+`cleaned_data` becomes the ``config`` dict on the resulting Job.
+
+Algorithm scope (which events / collection / queryset) lives outside the form
+because it varies per admin entry-point — see the per-action helpers in
+``ami/main/admin.py``.
+"""
+from __future__ import annotations
+
+from django import forms
+from django.db.models import QuerySet
+
+from ami.main.models import Classification, Event
+from ami.ml.models import Algorithm
+from ami.ml.post_processing.tracking_task import DEFAULT_TRACKING_PARAMS
+
+
+def _feature_algorithm_choices_for_events(events: QuerySet[Event]) -> list[tuple[int, str]]:
+    """Algorithms that produced ``features_2048`` on the given events.
+
+    Scoped to the operator's selection so the dropdown stays bounded on
+    production-sized DBs and never reveals algorithms from other projects.
+    """
+    algorithm_ids = (
+        Classification.objects.filter(
+            detection__source_image__event__in=events,
+            features_2048__isnull=False,
+            algorithm_id__isnull=False,
+        )
+        .values_list("algorithm_id", flat=True)
+        .distinct()
+    )
+    return [
+        (a.pk, f"{a.name} (#{a.pk})") for a in Algorithm.objects.filter(pk__in=list(algorithm_ids)).order_by("name")
+    ]
+
+
+class TrackingActionForm(forms.Form):
+    """Knobs surfaced when an admin triggers Occurrence Tracking.
+
+    Pass the events the action will run on as ``events`` so the
+    feature-extraction-algorithm dropdown is scoped correctly. The class is
+    constructed once for the GET (rendering defaults) and once for the POST
+    (validating submitted values); pass the same queryset both times.
+    """
+
+    cost_threshold = forms.FloatField(
+        label="Cost threshold",
+        initial=DEFAULT_TRACKING_PARAMS.cost_threshold,
+        min_value=0.0,
+        help_text=(
+            "Maximum sum of (1 - cosine similarity) + (1 - IoU) + (1 - box ratio) + "
+            "(distance / image diagonal) for two detections to be considered the "
+            "same individual. Lower = stricter matching, fewer false links. "
+            "Default 0.2 is calibrated against synthetic features; tune per dataset."
+        ),
+    )
+
+    skip_if_human_identifications = forms.BooleanField(
+        label="Skip events with human identifications",
+        initial=DEFAULT_TRACKING_PARAMS.skip_if_human_identifications,
+        required=False,
+        help_text=(
+            "If checked, events that already have any user-confirmed identification "
+            "are skipped to preserve manual review work. Recommended on."
+        ),
+    )
+
+    require_fresh_event = forms.BooleanField(
+        label="Require fresh event (v1)",
+        initial=DEFAULT_TRACKING_PARAMS.require_fresh_event,
+        required=False,
+        help_text=(
+            "v1 only handles events where every detection has its own auto-created "
+            "occurrence (1:1) and no chain links exist. Skip already-tracked events. "
+            "Re-tracking lands in v2."
+        ),
+    )
+
+    feature_extraction_algorithm_id = forms.ChoiceField(
+        label="Feature extraction algorithm",
+        required=False,
+        help_text=(
+            "Override the algorithm whose embeddings are used for matching. Leave "
+            "blank to auto-detect (works when only one feature-extracting algorithm "
+            "ran on the event). Required when multiple algorithms have produced "
+            "embeddings on the same event."
+        ),
+    )
+
+    def __init__(self, *args, events: QuerySet[Event] | None = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        choices: list[tuple[str, str]] = [("", "— auto-detect —")]
+        if events is not None:
+            choices.extend((str(pk), label) for pk, label in _feature_algorithm_choices_for_events(events))
+        self.fields["feature_extraction_algorithm_id"].choices = choices
+
+    def to_config(self) -> dict:
+        """Return the ``cleaned_data`` shape the TrackingTask expects in ``Job.params['config']``.
+
+        Drops the algorithm override when blank so ``_params()`` falls through to
+        auto-detection rather than logging an "unknown key" warning.
+        """
+        if not self.is_valid():
+            raise ValueError(f"TrackingActionForm has errors: {self.errors.as_text()}")
+        config = {
+            "cost_threshold": self.cleaned_data["cost_threshold"],
+            "skip_if_human_identifications": self.cleaned_data["skip_if_human_identifications"],
+            "require_fresh_event": self.cleaned_data["require_fresh_event"],
+        }
+        algo_id_str = self.cleaned_data.get("feature_extraction_algorithm_id") or ""
+        if algo_id_str:
+            config["feature_extraction_algorithm_id"] = int(algo_id_str)
+        return config
diff --git a/ami/ml/post_processing/registry.py b/ami/ml/post_processing/registry.py
index 308be18ae..b7263838c 100644
--- a/ami/ml/post_processing/registry.py
+++ b/ami/ml/post_processing/registry.py
@@ -1,13 +1,43 @@
 # Registry of available post-processing tasks
 from ami.ml.post_processing.class_masking import ClassMaskingTask
 from ami.ml.post_processing.small_size_filter import SmallSizeFilterTask
+from ami.ml.post_processing.tracking_task import TrackingTask
 
 POSTPROCESSING_TASKS = {
     SmallSizeFilterTask.key: SmallSizeFilterTask,
     ClassMaskingTask.key: ClassMaskingTask,
+    TrackingTask.key: TrackingTask,
 }
 
 
 def get_postprocessing_task(key: str):
     """Return a post-processing task class by key."""
     return POSTPROCESSING_TASKS.get(key)
+
+
+# Post-processing tasks a project member may start through the jobs API, with the config
+# fields a member may set. Every other field must keep its schema default: the other tasks
+# and the safety guards (such as re-tracking grouped sessions) are staff tools.
+MEMBER_POST_PROCESSING_TASKS: dict[str, frozenset[str]] = {
+    TrackingTask.key: frozenset(
+        {
+            "source_image_collection_id",
+            "event_ids",
+            "cost_threshold",
+            "require_features",
+            "feature_extraction_algorithm_id",
+            "require_completely_processed_session",
+        }
+    ),
+}
+
+
+def staff_only_config_fields(task_key: str, config: dict) -> list[str]:
+    """Return the fields in ``config`` that only staff may set away from their default."""
+    schema_fields = POSTPROCESSING_TASKS[task_key].config_schema.__fields__
+    allowed = MEMBER_POST_PROCESSING_TASKS.get(task_key, frozenset())
+    return sorted(
+        name
+        for name, value in config.items()
+        if name in schema_fields and name not in allowed and value != schema_fields[name].default
+    )
diff --git a/ami/ml/post_processing/tests/test_tracking_admin.py b/ami/ml/post_processing/tests/test_tracking_admin.py
new file mode 100644
index 000000000..841949e54
--- /dev/null
+++ b/ami/ml/post_processing/tests/test_tracking_admin.py
@@ -0,0 +1,139 @@
+"""Admin-action tests for the Occurrence Tracking trigger.
+
+Covers both entry points. The Events changelist can span projects, so its
+selection is partitioned into one Job per project; the capture-set changelist
+uses the shared one-Job-per-row path.
+"""
+from django.contrib import admin as django_admin
+from django.test import Client, TestCase
+from django.urls import reverse
+
+from ami.jobs.models import Job
+from ami.main.models import SourceImageCollection
+from ami.tests.fixtures.main import create_captures, setup_test_project
+from ami.users.models import User
+
+
+class _TrackingAdminCase(TestCase):
+    @classmethod
+    def setUpTestData(cls) -> None:
+        cls.superuser = User.objects.create_superuser(
+            email=f"trackadmin+{cls.__name__}@example.com",
+            password="x",
+        )
+        cls.project, cls.deployment = setup_test_project(reuse=False)
+        create_captures(deployment=cls.deployment, num_nights=1, images_per_night=2, interval_minutes=1)
+        event = cls.project.events.first()
+        assert event is not None
+        cls.event = event
+
+    def setUp(self) -> None:
+        self.client = Client()
+        self.client.force_login(self.superuser)
+
+    @staticmethod
+    def _knobs(**overrides) -> dict:
+        """Form payload for a confirmed submit. Unchecked booleans are absent, as in HTML."""
+        return {
+            "confirm": "yes",
+            "cost_threshold": "0.2",
+            "skip_if_human_identifications": "on",
+            "require_features": "on",
+            "require_fresh_event": "on",
+            "feature_extraction_algorithm_id": "",
+            **overrides,
+        }
+
+
+class TestEventAdminTrackingAction(_TrackingAdminCase):
+    def _post(self, data: dict, pks: list[int] | None = None):
+        url = reverse("admin:main_event_changelist")
+        selected = [str(pk) for pk in (pks or [self.event.pk])]
+        return self.client.post(
+            url,
+            data={
+                "action": "run_tracking",
+                django_admin.helpers.ACTION_CHECKBOX_NAME: selected,
+                **data,
+            },
+        )
+
+    def test_renders_intermediate_page_without_confirm(self):
+        response = self._post({})
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(b"Run Occurrence Tracking", response.content)
+        self.assertIn(b'name="cost_threshold"', response.content)
+        self.assertEqual(Job.objects.filter(job_type_key="post_processing").count(), 0)
+
+    def test_confirmation_page_says_when_the_project_has_not_enabled_tracking(self):
+        """Staff may run tracking regardless of the flag, but are told members cannot yet edit the result."""
+        self.project.feature_flags.tracking = False
+        self.project.save(update_fields=["feature_flags"])
+        response = self._post({})
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "Tracking is not enabled for")
+
+        self.project.feature_flags.tracking = True
+        self.project.save(update_fields=["feature_flags"])
+        response = self._post({})
+        self.assertNotContains(response, "Tracking is not enabled for")
+
+    def test_runs_even_when_the_project_has_not_enabled_tracking(self):
+        self.project.feature_flags.tracking = False
+        self.project.save(update_fields=["feature_flags"])
+        response = self._post(self._knobs())
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(Job.objects.filter(job_type_key="post_processing", project=self.project).count(), 1)
+
+    def test_creates_one_job_per_project_carrying_its_own_events(self):
+        other_project, other_deployment = setup_test_project(reuse=False)
+        create_captures(deployment=other_deployment, num_nights=1, images_per_night=2, interval_minutes=1)
+        other_event = other_project.events.first()
+        assert other_event is not None
+
+        response = self._post(
+            self._knobs(cost_threshold="0.35", require_fresh_event=""),
+            pks=[self.event.pk, other_event.pk],
+        )
+        self.assertEqual(response.status_code, 302)
+
+        jobs = Job.objects.filter(job_type_key="post_processing")
+        self.assertEqual(jobs.count(), 2)
+        by_project = {job.project_id: job for job in jobs}
+        self.assertEqual(set(by_project), {self.project.pk, other_project.pk})
+
+        for job in jobs:
+            config = job.params["config"]
+            self.assertEqual(config["cost_threshold"], 0.35)
+            self.assertTrue(config["skip_if_human_identifications"])
+            self.assertFalse(config["require_fresh_event"])
+            self.assertIsNone(config["feature_extraction_algorithm_id"])
+
+        self.assertEqual(by_project[self.project.pk].params["config"]["event_ids"], [self.event.pk])
+        self.assertEqual(by_project[other_project.pk].params["config"]["event_ids"], [other_event.pk])
+
+
+class TestCollectionAdminTrackingAction(_TrackingAdminCase):
+    def setUp(self) -> None:
+        super().setUp()
+        self.collection = SourceImageCollection.objects.create(
+            project=self.project, name="Tracking admin test collection"
+        )
+        self.collection.images.set(self.event.captures.all())
+
+    def test_creates_job_scoped_to_the_capture_set(self):
+        response = self.client.post(
+            reverse("admin:main_sourceimagecollection_changelist"),
+            data={
+                "action": "run_tracking",
+                django_admin.helpers.ACTION_CHECKBOX_NAME: [str(self.collection.pk)],
+                **self._knobs(require_features=""),
+            },
+        )
+        self.assertEqual(response.status_code, 302)
+
+        job = Job.objects.get(job_type_key="post_processing")
+        self.assertEqual(job.project_id, self.project.pk)
+        self.assertEqual(job.params["config"]["source_image_collection_id"], self.collection.pk)
+        self.assertEqual(job.params["config"]["event_ids"], [])
+        self.assertFalse(job.params["config"]["require_features"])
diff --git a/ami/ml/post_processing/tests/test_tracking_evaluation.py b/ami/ml/post_processing/tests/test_tracking_evaluation.py
new file mode 100644
index 000000000..2e33f9fb7
--- /dev/null
+++ b/ami/ml/post_processing/tests/test_tracking_evaluation.py
@@ -0,0 +1,432 @@
+import contextlib
+import csv
+import io
+import json
+import logging
+import pathlib
+import tempfile
+
+from django.core.management import CommandError, call_command
+from django.test import SimpleTestCase, TestCase
+from django.utils import timezone
+
+from ami.main.models import Classification, Detection, Event, Occurrence
+from ami.ml.post_processing.tracking_evaluation import (
+    describe_confirmed_set,
+    evaluate_csv_files,
+    evaluate_tracks,
+    main,
+    tracks_from_links,
+)
+from ami.ml.post_processing.tracking_task import TrackingConfig, TrackingTask, propose_event_links
+from ami.tests.fixtures.main import create_taxa, setup_test_project
+from ami.tests.fixtures.tracking import create_tracking_session
+
+logger = logging.getLogger(__name__)
+
+# Three confirmed tracks: A has four detections, B two, C one. B runs alongside A in time.
+GROUND_TRUTH = {1: "A", 2: "A", 3: "A", 4: "A", 5: "B", 6: "B", 7: "C"}
+TIMESTAMPS = {1: 1, 2: 2, 3: 3, 4: 4, 5: 1, 6: 2, 7: 3}
+
+
+def _evaluate(predictions: dict, timestamps: dict | None = None):
+    return evaluate_tracks(GROUND_TRUTH, predictions, timestamps or TIMESTAMPS)
+
+
+class TestEvaluateTracks(SimpleTestCase):
+    def test_perfect_prediction_scores_one_everywhere(self):
+        result = _evaluate({1: "x", 2: "x", 3: "x", 4: "x", 5: "y", 6: "y", 7: "z"})
+        self.assertEqual((result.pairwise_precision, result.pairwise_recall, result.pairwise_f1), (1.0, 1.0, 1.0))
+        self.assertEqual((result.link_precision, result.link_recall), (1.0, 1.0))
+        self.assertEqual((result.links_correct, result.links_ground_truth), (4, 4))
+        self.assertEqual((result.exactly_recovered, result.merges, result.fragmented_tracks), (3, 0, 0))
+        self.assertEqual((result.ground_truth_tracks, result.detections, result.ground_truth_singletons), (3, 7, 1))
+
+    def test_fully_fragmented_prediction_has_no_recall_and_undefined_precision(self):
+        result = _evaluate({d: f"p{d}" for d in GROUND_TRUTH})
+        self.assertEqual(result.pairwise_predicted, 0)
+        self.assertIsNone(result.pairwise_precision)
+        self.assertEqual(result.pairwise_recall, 0.0)
+        self.assertIsNone(result.link_precision)
+        self.assertEqual(result.link_recall, 0.0)
+        track_a = next(s for s in result.ground_truth_track_scores if s.track_id == "A")
+        self.assertEqual((track_a.fragments, track_a.completeness), (4, 0.25))
+        self.assertEqual(result.exactly_recovered, 1, "Only the single-detection track is recovered")
+
+    def test_over_merged_prediction_keeps_recall_and_loses_precision(self):
+        result = _evaluate({d: "all" for d in GROUND_TRUTH})
+        self.assertEqual((result.pairwise_true_positives, result.pairwise_predicted), (7, 21))
+        self.assertAlmostEqual(result.pairwise_precision, 1 / 3)
+        self.assertEqual(result.pairwise_recall, 1.0)
+        self.assertEqual(result.merges, 1)
+        (merged,) = result.predicted_track_scores
+        self.assertEqual((merged.ground_truth_tracks, merged.purity), (3, 4 / 7))
+        # Interleaving A and B in time means no consecutive predicted pair is a true link.
+        self.assertEqual((result.links_correct, result.links_predicted), (0, 6))
+
+    def test_one_missed_link_splits_a_track_in_two(self):
+        result = _evaluate({1: "x", 2: "x", 3: "w", 4: "w", 5: "y", 6: "y", 7: "z"})
+        self.assertEqual((result.pairwise_precision, result.pairwise_recall), (1.0, 3 / 7))
+        self.assertEqual((result.link_precision, result.link_recall), (1.0, 0.75))
+        track_a = next(s for s in result.ground_truth_track_scores if s.track_id == "A")
+        self.assertEqual((track_a.fragments, track_a.completeness, track_a.exactly_recovered), (2, 0.5, False))
+        self.assertEqual((result.fragmented_tracks, result.merges), (1, 0))
+
+    def test_detections_outside_confirmed_tracks_are_ignored(self):
+        perfect = _evaluate({1: "x", 2: "x", 3: "x", 4: "x", 5: "y", 6: "y", 7: "z"})
+        # Detection 99 sits between 1 and 2 in the predicted track; 100 joins track B's prediction.
+        with_unknowns = _evaluate(
+            {1: "x", 99: "x", 2: "x", 3: "x", 4: "x", 5: "y", 6: "y", 100: "y", 7: "z"},
+            timestamps={**TIMESTAMPS, 99: 1.5, 100: 3},
+        )
+        self.assertEqual(with_unknowns.to_dict(), perfect.to_dict())
+
+    def test_detection_missing_from_predictions_is_its_own_track(self):
+        result = _evaluate({1: "x", 2: "x", 3: "x", 5: "y", 6: "y", 7: "z"})
+        track_a = next(s for s in result.ground_truth_track_scores if s.track_id == "A")
+        self.assertEqual((track_a.fragments, track_a.completeness), (2, 0.75))
+
+    def test_missing_timestamp_is_an_error(self):
+        with self.assertRaises(ValueError):
+            evaluate_tracks(GROUND_TRUTH, {}, {1: 1})
+
+    def test_result_serialises_to_json(self):
+        result = _evaluate({d: "all" for d in GROUND_TRUTH})
+        payload = json.loads(json.dumps(result.to_dict()))
+        self.assertEqual(payload["merges"], 1)
+        self.assertNotIn("ground_truth_track_scores", result.to_dict(include_tracks=False))
+
+    def test_predicted_tracks_are_named_by_their_first_detection_not_a_track_id(self):
+        """Confirmed tracks are keyed by occurrence id under ``track_id``; predicted tracks must
+        use a key of their own, or a detection id reads as an occurrence id in the output."""
+        # Detection 4 is left out of the predictions, so it is a predicted track of its own.
+        result = _evaluate({1: "x", 2: "x", 3: "x", 5: "y", 6: "y", 7: "z"})
+        predicted = result.to_dict()["predicted_track_scores"]
+        self.assertEqual([p["first_detection_id"] for p in predicted], [1, 4, 5, 7])
+        self.assertFalse(any("track_id" in p for p in predicted))
+        self.assertEqual([g["track_id"] for g in result.to_dict()["ground_truth_track_scores"]], ["A", "B", "C"])
+
+
+class TestIdentityScores(SimpleTestCase):
+    """IDF1, ID switches and the mostly tracked / partly tracked / mostly lost split."""
+
+    def test_perfect_prediction_has_idf1_one_and_no_switches(self):
+        result = _evaluate({1: "x", 2: "x", 3: "x", 4: "x", 5: "y", 6: "y", 7: "z"})
+        self.assertEqual((result.idf1, result.id_true_positives, result.id_switches), (1.0, 7, 0))
+        self.assertEqual((result.mostly_tracked, result.partly_tracked, result.mostly_lost), (3, 0, 0))
+
+    def test_idf1_is_the_share_of_detections_in_their_matched_predicted_track(self):
+        # Track A is split 2 + 2, so only one half of it can be matched: 5 of 7 detections.
+        split = _evaluate({1: "x", 2: "x", 3: "w", 4: "w", 5: "y", 6: "y", 7: "z"})
+        self.assertAlmostEqual(split.idf1, 5 / 7)
+        # One predicted track can be matched to one confirmed track only: A's four detections.
+        merged = _evaluate({d: "all" for d in GROUND_TRUTH})
+        self.assertAlmostEqual(merged.idf1, 4 / 7)
+
+    def test_idf1_matches_tracks_one_to_one_for_the_largest_total_overlap(self):
+        # A has 3 detections in p and 2 in q; B has 2 in p. Greedily matching A to p leaves
+        # B unmatched (3 correct); matching A to q and B to p gets 4 right.
+        ground_truth = {1: "A", 2: "A", 3: "A", 4: "A", 5: "A", 6: "B", 7: "B"}
+        predictions = {1: "p", 2: "p", 3: "p", 4: "q", 5: "q", 6: "p", 7: "p"}
+        result = evaluate_tracks(ground_truth, predictions, {d: d for d in ground_truth})
+        self.assertEqual(result.id_true_positives, 4)
+        self.assertAlmostEqual(result.idf1, 4 / 7)
+
+    def test_id_switches_count_every_change_of_predicted_track_in_time_order(self):
+        ground_truth = {1: "X", 2: "X", 3: "X", 4: "X"}
+        times = {1: 1, 2: 2, 3: 3, 4: 4}
+        alternating = evaluate_tracks(ground_truth, {1: "a", 2: "b", 3: "a", 4: "b"}, times)
+        blocks = evaluate_tracks(ground_truth, {1: "a", 2: "a", 3: "b", 4: "b"}, times)
+        for result, switches in [(alternating, 3), (blocks, 1)]:
+            (track,) = result.ground_truth_track_scores
+            self.assertEqual((track.fragments, track.id_switches, result.id_switches), (2, switches, switches))
+
+    def test_tracks_split_into_mostly_tracked_partly_tracked_and_mostly_lost(self):
+        # Share of each track in its largest predicted piece: 5/5, 4/5, 3/5, 1/5 and 1/6.
+        pieces = {"T1": [5], "T2": [4, 1], "T3": [3, 1, 1], "T4": [1] * 5, "T5": [1] * 6}
+        ground_truth, predictions = {}, {}
+        for track_id, sizes in pieces.items():
+            for piece, size in enumerate(sizes):
+                for _ in range(size):
+                    detection_id = len(ground_truth)
+                    ground_truth[detection_id] = track_id
+                    predictions[detection_id] = f"{track_id}-{piece}"
+        result = evaluate_tracks(ground_truth, predictions, {d: d for d in ground_truth})
+        self.assertEqual((result.mostly_tracked, result.partly_tracked, result.mostly_lost), (2, 2, 1))
+
+    def test_summary_leads_with_idf1(self):
+        result = _evaluate({d: "all" for d in GROUND_TRUTH})
+        self.assertTrue(result.summary_lines()[0].startswith("IDF1 0.571"))
+
+
+class TestDescribeConfirmedSet(SimpleTestCase):
+    def test_confirmed_tracks_are_profiled_next_to_every_track_in_the_session(self):
+        # Capture 10 holds detections 1-3, capture 20 holds 4-5, capture 30 holds 6.
+        captures = {1: 10, 2: 10, 3: 10, 4: 20, 5: 20, 6: 30}
+        ground_truth = {1: "A", 4: "A", 6: "B"}
+        predictions = {1: 1, 4: 1, 2: 2, 5: 2, 3: 3, 6: 6}
+        bias = describe_confirmed_set(ground_truth, predictions, captures)
+        confirmed, session = bias.confirmed, bias.session
+        self.assertEqual((confirmed.tracks, confirmed.singletons, confirmed.max_length), (2, 1, 2))
+        self.assertEqual((confirmed.median_length, confirmed.mean_length), (1.5, 1.5))
+        self.assertEqual(confirmed.mean_detections_per_capture, 2.0)
+        self.assertEqual((session.tracks, session.singletons, session.max_length), (4, 2, 2))
+        self.assertAlmostEqual(session.mean_detections_per_capture, 14 / 6)
+        self.assertIn("confirmed", bias.summary_lines()[0].lower())
+
+    def test_confirmed_detection_without_a_capture_is_an_error(self):
+        with self.assertRaises(ValueError):
+            describe_confirmed_set({1: "A"}, {1: 1}, {})
+
+
+class TestTracksFromLinks(SimpleTestCase):
+    def test_chains_take_the_id_of_their_first_detection(self):
+        tracks = tracks_from_links([1, 2, 3, 4, 5], [(1, 2), (2, 3), (4, 5)])
+        self.assertEqual(tracks, {1: 1, 2: 1, 3: 1, 4: 4, 5: 4})
+
+    def test_unlinked_detections_are_singletons(self):
+        self.assertEqual(tracks_from_links([7, 8], []), {7: 7, 8: 8})
+
+    def test_branching_links_are_rejected(self):
+        with self.assertRaises(ValueError):
+            tracks_from_links([1, 2, 3], [(1, 2), (1, 3)])
+
+    def test_cycles_are_rejected(self):
+        with self.assertRaises(ValueError):
+            tracks_from_links([1, 2], [(1, 2), (2, 1)])
+
+
+CSV_COLUMNS = ["occurrence_id", "detection_id", "timestamp", "frame_index", "grouping_verified"]
+
+
+def _write_csv(path: pathlib.Path, rows: list[tuple]) -> str:
+    with open(path, "w", newline="") as handle:
+        writer = csv.writer(handle)
+        writer.writerow(CSV_COLUMNS)
+        writer.writerows(rows)
+    return str(path)
+
+
+class TestCsvAdapter(SimpleTestCase):
+    def setUp(self) -> None:
+        self.directory = tempfile.TemporaryDirectory()
+        self.addCleanup(self.directory.cleanup)
+        root = pathlib.Path(self.directory.name)
+        # Occurrence 10 is confirmed; occurrence 20 is not, so its detection is not scored.
+        self.ground_truth = _write_csv(
+            root / "gt.csv",
+            [
+                (10, 1, "2026-06-01T22:00:00", 0, "true"),
+                (10, 2, "2026-06-01T22:01:00", 1, "true"),
+                (10, 3, "2026-06-01T22:02:00", 2, "true"),
+                (20, 4, "2026-06-01T22:00:00", 0, "false"),
+            ],
+        )
+        self.predictions = _write_csv(
+            root / "pred.csv",
+            [(5, 1, "", "", ""), (5, 2, "", "", ""), (6, 3, "", "", ""), (6, 4, "", "", "")],
+        )
+
+    def test_only_confirmed_rows_are_ground_truth(self):
+        result = evaluate_csv_files(self.ground_truth, self.predictions)
+        self.assertEqual((result.ground_truth_tracks, result.detections), (1, 3))
+        self.assertEqual((result.links_correct, result.links_ground_truth), (1, 2))
+        self.assertEqual(result.merges, 0)
+
+    def _ground_truth_with_times(self, *times: str) -> str:
+        rows = [(10, i + 1, t, i, "true") for i, t in enumerate(times)]
+        return _write_csv(pathlib.Path(self.directory.name) / "gt-times.csv", rows)
+
+    def test_blank_or_unreadable_timestamps_on_confirmed_rows_are_refused_by_id(self):
+        for times, message in [
+            (("2026-06-01T22:00:00", "", "2026-06-01T22:02:00"), "no timestamp, e.g. detection_id ['2']"),
+            (("2026-06-01T22:00:00", "last night", "2026-06-01T22:02:00"), "not ISO 8601, e.g. detection_id ['2']"),
+            (("2026-06-01T22:00:00+02:00", "2026-06-01T22:01:00", "2026-06-01T22:02:00"), "timezone-aware and naive"),
+        ]:
+            with self.subTest(times=times), self.assertRaisesMessage(ValueError, message):
+                evaluate_csv_files(self._ground_truth_with_times(*times), self.predictions)
+
+    def test_entry_point_reports_a_bad_file_without_a_traceback(self):
+        ground_truth = self._ground_truth_with_times("2026-06-01T22:00:00", "", "2026-06-01T22:02:00")
+        errors = io.StringIO()
+        with contextlib.redirect_stderr(errors), self.assertRaises(SystemExit) as exit_:
+            main(["--ground-truth", ground_truth, "--predictions", self.predictions])
+        self.assertEqual(exit_.exception.code, 2)
+        self.assertIn("no timestamp", errors.getvalue())
+
+    def test_entry_point_prints_json(self):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            main(["--ground-truth", self.ground_truth, "--predictions", self.predictions, "--format", "json"])
+        self.assertEqual(json.loads(output.getvalue())["pairwise_recall"], 1 / 3)
+
+
+class TestEvaluateTrackingCommand(TestCase):
+    """The command scores a fresh re-link of confirmed sessions and never changes stored data."""
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        self.ground_truth = create_tracking_session(
+            self.deployment,
+            taxa_list=create_taxa(self.project),
+            num_frames=8,
+            num_moths=3,
+            num_transient_moths=2,
+            min_frames_per_moth=4,
+            create_crops=False,
+        )
+        self.event = Event.objects.get(pk=self.ground_truth.event_id)
+
+    def _track_and_confirm(self) -> None:
+        TrackingTask(logger=logger, event_ids=[self.event.pk], require_features=False, cost_threshold=0.4).run()
+        Occurrence.objects.filter(event=self.event).update(grouping_verified_at=timezone.now())
+
+    def _snapshot(self) -> dict:
+        return {
+            "detections": list(
+                Detection.objects.filter(source_image__event=self.event)
+                .order_by("pk")
+                .values_list("pk", "occurrence_id", "next_detection_id")
+            ),
+            "occurrences": list(
+                Occurrence.objects.filter(event=self.event)
+                .order_by("pk")
+                .values_list("pk", "determination_id", "grouping_verified_at", "updated_at")
+            ),
+            "occurrence_count": Occurrence.objects.count(),
+            "classification_count": Classification.objects.count(),
+        }
+
+    def _run(self, *args: str) -> dict:
+        output = io.StringIO()
+        call_command("evaluate_tracking", "--project", str(self.project.pk), "--format", "json", *args, stdout=output)
+        return json.loads(output.getvalue())
+
+    def test_proposed_links_are_the_links_a_tracking_run_saves(self):
+        config = TrackingConfig(event_ids=[self.event.pk], require_features=False, cost_threshold=0.4)
+        proposed = {(a, b) for a, b, _ in propose_event_links(self.event, None, config, logger)}
+        self.assertFalse(
+            Detection.objects.filter(source_image__event=self.event, next_detection__isnull=False).exists()
+        )
+        TrackingTask(logger=logger, event_ids=[self.event.pk], require_features=False, cost_threshold=0.4).run()
+        saved = set(
+            Detection.objects.filter(source_image__event=self.event, next_detection__isnull=False).values_list(
+                "pk", "next_detection_id"
+            )
+        )
+        self.assertTrue(proposed)
+        self.assertEqual(proposed, saved)
+
+    def test_confirmed_tracks_rebuilt_exactly_score_perfectly_and_nothing_is_written(self):
+        self._track_and_confirm()
+        before = self._snapshot()
+
+        report = self._run("--no-require-features", "--cost-threshold", "0.4")
+
+        self.assertEqual(self._snapshot(), before)
+        overall = report["overall"]
+        self.assertEqual(overall["ground_truth_tracks"], len(self.ground_truth.insects))
+        self.assertEqual(overall["exactly_recovered"], len(self.ground_truth.insects))
+        self.assertEqual((overall["pairwise_f1"], overall["link_f1"]), (1.0, 1.0))
+        self.assertEqual([entry["event_id"] for entry in report["events"]], [self.event.pk])
+
+    def test_text_report_leads_with_idf1_and_profiles_the_confirmed_set(self):
+        self._track_and_confirm()
+        output = io.StringIO()
+        call_command(
+            "evaluate_tracking",
+            "--project",
+            str(self.project.pk),
+            "--no-require-features",
+            "--cost-threshold",
+            "0.4",
+            stdout=output,
+        )
+        text = output.getvalue()
+        overall = text[text.index("\nOverall") :]
+        self.assertIn("Weighting:", text)
+        self.assertLess(overall.index("IDF1 1.000"), overall.index("Pairwise precision"))
+        self.assertIn("Confirmed tracks vs the whole session", overall)
+
+        report = self._run("--no-require-features", "--cost-threshold", "0.4")
+        self.assertEqual(report["overall"]["idf1"], 1.0)
+        self.assertEqual(report["confirmed_vs_session"]["confirmed"]["tracks"], len(self.ground_truth.insects))
+        self.assertIn("confirmed_vs_session", report["events"][0])
+
+    def test_predictions_come_from_relinking_not_from_the_stored_tracks(self):
+        self._track_and_confirm()
+        before = self._snapshot()
+
+        # A threshold nothing passes links nothing, although the stored tracks are perfect.
+        report = self._run("--no-require-features", "--cost-threshold", "0")
+
+        self.assertEqual(self._snapshot(), before)
+        self.assertEqual(report["overall"]["pairwise_recall"], 0.0)
+        self.assertEqual(report["events"][0]["links_proposed"], 0)
+
+    def test_sessions_without_confirmed_tracks_are_refused(self):
+        with self.assertRaises(CommandError):
+            self._run()
+
+    def test_default_run_compares_the_session_embeddings(self):
+        if self.ground_truth.feature_algorithm_key is None:
+            self.skipTest("This database cannot store embeddings.")
+        self._track_and_confirm()
+
+        report = self._run()
+
+        self.assertEqual(report["skipped_events"], [])
+        self.assertEqual([entry["event_id"] for entry in report["events"]], [self.event.pk])
+        self.assertIsNotNone(report["events"][0]["feature_extraction_algorithm_id"])
+        self.assertEqual(report["overall"]["exactly_recovered"], len(self.ground_truth.insects))
+
+    def test_default_run_skips_sessions_without_embeddings(self):
+        # Features are required by default, so a session with no embeddings is reported, not scored.
+        self._track_and_confirm()
+        Classification.objects.filter(detection__source_image__event=self.event).update(features_2048=None)
+        confirmed = Detection.objects.filter(
+            source_image__event=self.event, occurrence__grouping_verified_at__isnull=False
+        ).count()
+
+        report = self._run()
+
+        self.assertEqual(report["events"], [])
+        self.assertIsNone(report["overall"])
+        self.assertEqual(len(report["skipped_events"]), 1)
+        skipped = report["skipped_events"][0]
+        self.assertEqual((skipped["event_id"], skipped["confirmed_detections"]), (self.event.pk, confirmed))
+        self.assertIn("no detections carry feature embeddings", skipped["reason"])
+
+        text = io.StringIO()
+        call_command("evaluate_tracking", "--project", str(self.project.pk), stdout=text)
+        self.assertIn("No session could be scored.", text.getvalue())
+
+    def test_event_option_scores_only_the_named_sessions(self):
+        self._track_and_confirm()
+        other = Event.objects.create(
+            project=self.project,
+            deployment=self.deployment,
+            group_by="2026-01-01",
+            start=self.event.start,
+            end=self.event.start,
+        )
+
+        report = self._run("--no-require-features", "--cost-threshold", "0.4", "--event", str(self.event.pk))
+        self.assertEqual([entry["event_id"] for entry in report["events"]], [self.event.pk])
+
+        with self.assertRaises(CommandError):
+            self._run("--no-require-features", "--event", str(other.pk))
+
+    def test_confirmed_detection_without_a_capture_time_is_refused(self):
+        self._track_and_confirm()
+        before = self._snapshot()
+        image = (
+            Detection.objects.filter(source_image__event=self.event, occurrence__grouping_verified_at__isnull=False)
+            .first()
+            .source_image
+        )
+        type(image).objects.filter(pk=image.pk).update(timestamp=None)
+
+        with self.assertRaisesMessage(CommandError, "without a timestamp"):
+            self._run("--no-require-features")
+        self.assertEqual(self._snapshot(), before)
diff --git a/ami/ml/post_processing/tests/test_tracking_task.py b/ami/ml/post_processing/tests/test_tracking_task.py
new file mode 100644
index 000000000..49b4f8864
--- /dev/null
+++ b/ami/ml/post_processing/tests/test_tracking_task.py
@@ -0,0 +1,762 @@
+import logging
+import threading
+import typing
+from collections import defaultdict
+from unittest import mock
+
+import numpy as np
+import pydantic
+from django.db import connection, transaction
+from django.test import SimpleTestCase, TestCase, TransactionTestCase
+from django.test.utils import CaptureQueriesContext
+from django.utils import timezone
+
+from ami.jobs.models import Job
+from ami.main.models import (
+    Classification,
+    Detection,
+    Event,
+    Identification,
+    Occurrence,
+    SourceImageCollection,
+    Taxon,
+    update_calculated_fields_for_events,
+)
+from ami.main.models_future.tracks import (
+    SessionBusy,
+    TrackEditError,
+    add_detections,
+    detach_detection,
+    lock_sessions,
+    merge_occurrences,
+    split_track,
+    unverify_grouping,
+    verify_grouping,
+)
+from ami.ml.models import Algorithm
+from ami.ml.post_processing.tracking_task import (
+    TrackingConfig,
+    TrackingTask,
+    assign_occurrences_by_tracking_images,
+    assign_occurrences_from_detection_chains,
+    event_is_fresh,
+)
+from ami.tests.fixtures.images import generate_moth_series
+from ami.tests.fixtures.main import create_captures, create_occurrences, create_taxa, setup_test_project
+from ami.tests.fixtures.tracking import create_tracking_session, score_tracking_run
+from ami.users.tests.factories import UserFactory
+
+logger = logging.getLogger(__name__)
+
+
+def _give_captures_dimensions(source_images) -> None:
+    """The cost function needs an image diagonal; test captures have no dimensions."""
+    for img in source_images:
+        if not img.width or not img.height:
+            img.width = 4096
+            img.height = 2160
+            img.save(update_fields=["width", "height"])
+
+
+class TestTracking(TestCase):
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        # 1 night, 5 captures spaced 1 minute apart so they group into one event.
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=5, interval_minutes=1)
+        create_taxa(self.project)
+        create_occurrences(deployment=self.deployment, num=6)
+
+        self.event = self.project.events.first()
+        assert self.event is not None
+        self.source_images = list(self.event.captures.order_by("timestamp"))
+        _give_captures_dimensions(self.source_images)
+
+        self.algorithm = self._assign_mock_features_to_occurrence_detections(self.event)
+
+        # Capture ground-truth groupings so we can compare after re-tracking.
+        self.ground_truth_groups = defaultdict(set)
+        for occ in Occurrence.objects.filter(event=self.event):
+            for det_id in Detection.objects.filter(occurrence=occ).values_list("id", flat=True):
+                self.ground_truth_groups[occ.pk].add(det_id)
+
+        Detection.objects.filter(source_image__event=self.event).update(next_detection=None)
+
+    def _assign_mock_features_to_occurrence_detections(
+        self, event, algorithm_name: str = "MockTrackingAlgorithm"
+    ) -> Algorithm:
+        algorithm, _ = Algorithm.objects.get_or_create(name=algorithm_name, key="mock-tracking-algo")
+        rng = np.random.default_rng(seed=42)
+
+        for occurrence in event.occurrences.all():
+            base_vector = rng.random(2048)
+            for det in occurrence.detections.all():
+                noisy = base_vector + rng.normal(0, 0.001, size=2048)
+                Classification.objects.update_or_create(
+                    detection=det,
+                    algorithm=algorithm,
+                    defaults={
+                        "timestamp": timezone.now(),
+                        "features_2048": noisy.tolist(),
+                        "terminal": True,
+                        "score": 1.0,
+                    },
+                )
+        return algorithm
+
+    def _two_frame_chain(self, first_score: float, second_score: float):
+        """Two singleton occurrences in consecutive captures, linked into one chain, whose
+        frames predict different taxa with the given scores."""
+        taxon_a, taxon_b = list(Taxon.objects.filter(projects=self.project).order_by("pk")[:2])
+        det_a = self.source_images[0].detections.order_by("pk").first()
+        det_b = self.source_images[1].detections.order_by("pk").first()
+        for det, taxon, score in ((det_a, taxon_a, first_score), (det_b, taxon_b, second_score)):
+            occurrence = Occurrence.objects.create(event=self.event, deployment=self.deployment, project=self.project)
+            det.occurrence = occurrence
+            det.next_detection = None
+            det.save()
+            Classification.objects.filter(detection=det).update(taxon=taxon, score=score)
+            occurrence.save()
+        det_a.next_detection = det_b
+        det_a.save()
+        return det_a, det_b, taxon_a, taxon_b
+
+    def test_a_changed_determination_is_recorded_as_a_tracking_classification(self):
+        """When the merge moves the determination to a later frame's prediction, one terminal
+        classification attributed to the tracking algorithm points at that prediction; a
+        second pass over the same chain adds nothing."""
+        tracking_algorithm = Algorithm.objects.create(name="Occurrence Tracking", key="tracking")
+        det_a, det_b, taxon_a, taxon_b = self._two_frame_chain(first_score=0.3, second_score=0.9)
+        assign_occurrences_from_detection_chains(self.source_images[:2], logger, record_as=tracking_algorithm)
+
+        keeper = Occurrence.objects.get(pk=det_a.occurrence_id)
+        self.assertEqual(keeper.determination, taxon_b)
+        recorded = Classification.objects.filter(algorithm=tracking_algorithm)
+        self.assertEqual(recorded.count(), 1)
+        record = recorded.get()
+        self.assertEqual(
+            (record.detection_id, record.taxon, record.score, record.terminal), (det_b.pk, taxon_b, 0.9, True)
+        )
+        # The fixture gives a detection more than one row for the same prediction, so pin the
+        # lineage by content rather than by row identity.
+        self.assertEqual(
+            (record.applied_to.detection_id, record.applied_to.taxon, record.applied_to.score),
+            (det_b.pk, taxon_b, 0.9),
+        )
+        self.assertNotEqual(record.applied_to.algorithm_id, tracking_algorithm.pk)
+
+        assign_occurrences_from_detection_chains(self.source_images[:2], logger, record_as=tracking_algorithm)
+        self.assertEqual(Classification.objects.filter(algorithm=tracking_algorithm).count(), 1)
+
+    def test_an_unchanged_determination_leaves_no_tracking_classification(self):
+        """A merge whose keeper already held the winning prediction records nothing."""
+        tracking_algorithm = Algorithm.objects.create(name="Occurrence Tracking", key="tracking")
+        det_a, det_b, taxon_a, _ = self._two_frame_chain(first_score=0.9, second_score=0.3)
+
+        assign_occurrences_from_detection_chains(self.source_images[:2], logger, record_as=tracking_algorithm)
+
+        keeper = Occurrence.objects.get(pk=det_a.occurrence_id)
+        self.assertEqual(keeper.determination, taxon_a)
+        self.assertEqual(keeper.detections.count(), 2)
+        self.assertFalse(Classification.objects.filter(algorithm=tracking_algorithm).exists())
+
+    def test_a_stored_link_into_a_confirmed_track_changes_nothing(self):
+        """A chain that reaches a confirmed occurrence through an earlier link is left as it
+        is, whichever end is confirmed: no frames move and neither occurrence is deleted."""
+        for confirmed_end in ("first", "second"):
+            with self.subTest(confirmed=confirmed_end):
+                det_a, det_b, _, _ = self._two_frame_chain(first_score=0.9, second_score=0.3)
+                confirmed_pk = det_a.occurrence_id if confirmed_end == "first" else det_b.occurrence_id
+                Occurrence.objects.filter(pk=confirmed_pk).update(grouping_verified_at=timezone.now())
+
+                counters = assign_occurrences_from_detection_chains(self.source_images[:2], logger)
+
+                self.assertEqual(counters["confirmed_chains_skipped"], 1)
+                det_a.refresh_from_db()
+                det_b.refresh_from_db()
+                self.assertNotEqual(det_a.occurrence_id, det_b.occurrence_id)
+                confirmed = Occurrence.objects.get(pk=confirmed_pk)
+                self.assertIsNotNone(confirmed.grouping_verified_at)
+                self.assertEqual(confirmed.detections.count(), 1)
+
+    def test_null_marker_sentinels_are_ignored(self):
+        """A capture marked "processed, nothing found" carries a bbox-less sentinel detection;
+        tracking must neither score it nor give it an occurrence."""
+        first, second = self.source_images[:2]
+        sentinel = Detection.objects.create(source_image=first, bbox=None, timestamp=first.timestamp)
+        Detection.objects.create(source_image=second, bbox=None, timestamp=second.timestamp)
+        occurrences_before = Occurrence.objects.filter(event=self.event).count()
+
+        task = TrackingTask(logger=logger, event_ids=[self.event.pk], require_features=False, cost_threshold=0.5)
+        task.run()
+
+        sentinel.refresh_from_db()
+        self.assertIsNone(sentinel.occurrence_id)
+        self.assertIsNone(sentinel.next_detection_id)
+        self.assertFalse(Detection.objects.filter(next_detection=sentinel).exists())
+        self.assertLessEqual(Occurrence.objects.filter(event=self.event).count(), occurrences_before)
+
+    def test_a_tracking_run_stores_track_statistics_on_every_occurrence_it_settles(self):
+        """After a run, the merged keeper and every coherent single-frame occurrence in the
+        images carry stored stats, so a re-run also fills in rows from before the fields existed."""
+        tracking_algorithm = Algorithm.objects.create(name="Occurrence Tracking", key="tracking")
+        det_a, det_b, _, _ = self._two_frame_chain(first_score=0.3, second_score=0.9)
+        images = self.source_images[:2]
+        self.assertTrue(
+            Occurrence.objects.filter(detections__source_image__in=images, track_motion__isnull=True).exists()
+        )
+
+        assign_occurrences_from_detection_chains(images, logger, record_as=tracking_algorithm)
+
+        keeper = Occurrence.objects.get(pk=det_a.occurrence_id)
+        self.assertEqual(keeper.detections.count(), 2)
+        self.assertGreaterEqual(keeper.track_motion, 0.0)
+        self.assertGreaterEqual(keeper.track_size_ratio, 1.0)
+        self.assertEqual(keeper.track_distinct_taxa, 2, "The two frames predict different taxa")
+        self.assertTrue(0.0 < keeper.track_id_agreement < 1.0, "The determination matches only some of the labels")
+        settled = Occurrence.objects.filter(detections__source_image__in=images).distinct()
+        self.assertGreater(settled.count(), 1)
+        self.assertFalse(settled.filter(track_motion__isnull=True).exists())
+
+    def test_tracking_reproduces_occurrence_groups(self):
+        # v1 fresh-data scenario: pipeline already created 1:1 detection/occurrence.
+        # Wipe only chain links so tracking has to rebuild them; occurrences stay so
+        # event_is_fresh() passes and tracking runs.
+        Detection.objects.filter(source_image__event=self.event).update(next_detection=None)
+
+        # Sanity-check the fresh invariant before running.
+        orphans = Detection.objects.filter(source_image__event=self.event, occurrence__isnull=True).count()
+        self.assertEqual(orphans, 0, "Test setup expects every detection to have an occurrence")
+
+        assign_occurrences_by_tracking_images(
+            event=self.event,
+            logger=logger,
+            algorithm=self.algorithm,
+            config=TrackingConfig(event_ids=[self.event.pk]),
+        )
+
+        new_groups = {
+            occ.pk: set(Detection.objects.filter(occurrence=occ).values_list("id", flat=True))
+            for occ in Occurrence.objects.filter(event=self.event)
+        }
+
+        self.assertEqual(
+            len(new_groups),
+            len(self.ground_truth_groups),
+            f"Expected {len(self.ground_truth_groups)} groups, got {len(new_groups)}",
+        )
+
+        gt_values = list(self.ground_truth_groups.values())
+        for new_set in new_groups.values():
+            self.assertIn(
+                new_set,
+                gt_values,
+                f"Reconstructed group {new_set} does not match any ground-truth group",
+            )
+
+
+class TestTrackingWithoutFeatures(TestCase):
+    """Tracking must still link detections when no embeddings were stored.
+
+    Data processed before embeddings existed has no ``features_2048``. With
+    ``require_features=False`` the appearance term is dropped and detections are
+    matched on bounding-box geometry alone.
+    """
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=5, interval_minutes=1)
+        create_taxa(self.project)
+        # The fixture gives every detection the same bbox, so consecutive captures
+        # look like one insect that never moved: geometry cost is 0.
+        create_occurrences(deployment=self.deployment, num=6)
+
+        self.event = self.project.events.first()
+        assert self.event is not None
+        _give_captures_dimensions(list(self.event.captures.all()))
+        self.detections_in_event = Detection.objects.filter(source_image__event=self.event).count()
+
+    def test_geometry_only_run_links_detections(self):
+        self.assertFalse(
+            Classification.objects.filter(
+                detection__source_image__event=self.event, features_2048__isnull=False
+            ).exists(),
+            "This test needs detections with no embeddings",
+        )
+
+        task = TrackingTask(
+            logger=logger,
+            event_ids=[self.event.pk],
+            require_features=False,
+            cost_threshold=0.5,
+        )
+        task.run()
+
+        linked = Detection.objects.filter(source_image__event=self.event, next_detection__isnull=False).count()
+        self.assertGreater(linked, 0, "Geometry-only tracking should link detections in consecutive captures")
+
+        longest_chain = max(occ.detections.count() for occ in Occurrence.objects.filter(event=self.event))
+        self.assertGreater(longest_chain, 1, "At least one occurrence should span several detections")
+        self.assertEqual(
+            Detection.objects.filter(source_image__event=self.event, occurrence__isnull=True).count(),
+            0,
+            "Every detection should still belong to an occurrence after tracking",
+        )
+
+    def test_session_and_station_counts_are_refreshed_after_tracking(self):
+        """The cached counts the session and station lists show follow the merged occurrences."""
+        update_calculated_fields_for_events(pks=[self.event.pk])
+        self.deployment.update_calculated_fields(save=True)
+        self.event.refresh_from_db()
+        before = self.event.occurrences_count
+
+        TrackingTask(logger=logger, event_ids=[self.event.pk], require_features=False, cost_threshold=0.5).run()
+
+        self.event.refresh_from_db()
+        self.deployment.refresh_from_db()
+        live = self.event.get_occurrences_count()
+        self.assertLess(live, before, "Tracking must merge occurrences for this test to mean anything")
+        self.assertEqual(self.event.occurrences_count, live)
+        self.assertEqual(self.deployment.occurrences_count, live)
+
+    def test_requiring_features_leaves_data_untouched(self):
+        before = Occurrence.objects.filter(event=self.event).count()
+
+        task = TrackingTask(logger=logger, event_ids=[self.event.pk], require_features=True)
+        task.run()
+
+        self.assertEqual(Occurrence.objects.filter(event=self.event).count(), before)
+        self.assertEqual(
+            Detection.objects.filter(source_image__event=self.event, next_detection__isnull=False).count(), 0
+        )
+
+
+def _one_box_in_two_captures(test: TransactionTestCase) -> None:
+    """One session of two captures with one detection each on the same box, each detection
+    on an occurrence of its own, so a geometry-only run links and merges them."""
+    test.project, test.deployment = setup_test_project(reuse=False)
+    create_captures(deployment=test.deployment, num_nights=1, images_per_night=2, interval_minutes=1)
+    create_taxa(test.project)
+    create_occurrences(deployment=test.deployment, num=2)
+    test.event = test.project.events.get()
+    _give_captures_dimensions(list(test.event.captures.all()))
+    test.first, test.second = list(
+        Occurrence.objects.filter(event=test.event).order_by("detections__source_image__timestamp")
+    )
+
+
+class TestConfirmedTracksAreFrozen(TestCase):
+    """A tracking run never adds frames to, removes frames from, or deletes a confirmed
+    occurrence, since confirmed tracks are the ground truth runs are scored against.
+
+    """
+
+    def setUp(self) -> None:
+        _one_box_in_two_captures(self)
+
+    def _run(self) -> dict[str, typing.Any]:
+        job = Job.objects.create(
+            name="Confirmed tracks test",
+            project=self.project,
+            job_type_key="post_processing",
+            params={"task": "tracking", "config": {"event_ids": [self.event.pk]}},
+        )
+        job.progress.add_stage("Post-processing", key="post_processing")
+        job.save()
+        TrackingTask(job=job, event_ids=[self.event.pk], require_features=False, cost_threshold=0.5).run()
+        job.refresh_from_db()
+        return {param.name: param.value for param in job.progress.get_stage("post_processing").params}
+
+    def test_an_unconfirmed_pair_is_merged(self):
+        params = self._run()
+
+        self.assertEqual(Occurrence.objects.filter(event=self.event).count(), 1)
+        self.assertEqual(params["Confirmed occurrences left unchanged"], 0)
+        self.assertEqual(params["Result"], "Tracked 1 session(s).")
+
+    def test_a_confirmed_occurrence_is_left_as_it_is(self):
+        user = UserFactory()
+        for confirmed, other in ((self.first, self.second), (self.second, self.first)):
+            with self.subTest(confirmed="first" if confirmed is self.first else "second"):
+                Occurrence.objects.filter(pk__in=[self.first.pk, self.second.pk]).update(
+                    grouping_verified_at=None, grouping_verified_by=None
+                )
+                Occurrence.objects.filter(pk=confirmed.pk).update(
+                    grouping_verified_at=timezone.now(), grouping_verified_by=user
+                )
+
+                params = self._run()
+
+                confirmed.refresh_from_db()
+                self.assertEqual(confirmed.grouping_verified_by, user)
+                self.assertEqual(confirmed.detections.count(), 1)
+                self.assertTrue(Occurrence.objects.filter(pk=other.pk).exists())
+                self.assertFalse(
+                    Detection.objects.filter(source_image__event=self.event, next_detection__isnull=False).exists()
+                )
+                self.assertEqual(params["Confirmed occurrences left unchanged"], 1)
+                self.assertEqual(params["Result"], "Tracked 1 session(s). Left 1 confirmed occurrence(s) unchanged.")
+
+
+class TestRunsAndEditsShareTheSessionLock(TestCase):
+    """A tracking run and a track edit on the same session run one after the other, never
+    interleaved, so neither writes an older copy of a row over the other's change."""
+
+    def setUp(self) -> None:
+        _one_box_in_two_captures(self)
+
+    def _run(self) -> None:
+        TrackingTask(logger=logger, event_ids=[self.event.pk], require_features=False, cost_threshold=0.5).run()
+
+    def _locks_the_session(self, queries: CaptureQueriesContext) -> bool:
+        return any('FROM "main_event"' in q["sql"] and "FOR UPDATE" in q["sql"] for q in queries.captured_queries)
+
+    def test_a_run_locks_the_session_and_writes_only_the_columns_it_changes(self):
+        with CaptureQueriesContext(connection) as queries:
+            self._run()
+
+        self.assertEqual(Occurrence.objects.filter(event=self.event).count(), 1, "The run must merge the pair")
+        self.assertTrue(self._locks_the_session(queries))
+        updates = [
+            q["sql"]
+            for q in queries.captured_queries
+            if q["sql"].startswith(('UPDATE "main_detection"', 'UPDATE "main_occurrence"'))
+        ]
+        self.assertTrue(updates)
+        for sql in updates:
+            set_clause = sql.split(" SET ", 1)[1].split(" WHERE ", 1)[0]
+            for column in ('"bbox"', '"path"', '"grouping_verified_at"', '"event_id"'):
+                self.assertNotIn(column, set_clause, sql)
+
+    def test_every_track_edit_locks_the_session(self):
+        user = UserFactory()
+        second_detection = self.second.detections.get()
+        edits = [
+            ("merge", lambda: merge_occurrences(self.first, [self.second])),
+            ("split", lambda: split_track(self.first, second_detection)),
+            ("add", lambda: add_detections(self.first, [Detection.objects.get(pk=second_detection.pk)])),
+            ("detach", lambda: detach_detection(self.first, second_detection)),
+            ("verify", lambda: verify_grouping(self.first, user)),
+            ("unverify", lambda: unverify_grouping(self.first)),
+        ]
+        for name, edit in edits:
+            with self.subTest(edit=name), CaptureQueriesContext(connection) as queries:
+                edit()
+                self.assertTrue(self._locks_the_session(queries))
+
+    def test_an_edit_loaded_before_a_run_sees_what_the_run_did(self):
+        """A request that loaded two occurrences, then waited while a run merged them, is
+        refused instead of acting on the rows it loaded."""
+        stale_first, stale_second = Occurrence.objects.get(pk=self.first.pk), Occurrence.objects.get(pk=self.second.pk)
+        self._run()
+
+        with self.assertRaises(TrackEditError):
+            merge_occurrences(stale_first, [stale_second])
+        with self.assertRaises(TrackEditError):
+            verify_grouping(stale_second, UserFactory())
+        self.assertEqual(stale_first.detections.count(), 2)
+
+
+class TestAnEditDoesNotWaitLongForARun(TransactionTestCase):
+    """An edit on a session a tracking run holds gives up after a short wait with a reason
+    the reviewer can act on, rather than waiting until the web server drops the request."""
+
+    def setUp(self) -> None:
+        _one_box_in_two_captures(self)
+
+    def test_an_edit_on_a_locked_session_is_refused_as_busy(self):
+        locked, release = threading.Event(), threading.Event()
+
+        def hold_the_session() -> None:
+            try:
+                with transaction.atomic():
+                    lock_sessions([self.event.pk])
+                    locked.set()
+                    release.wait(timeout=30)
+            finally:
+                connection.close()
+
+        holder = threading.Thread(target=hold_the_session)
+        holder.start()
+        try:
+            self.assertTrue(locked.wait(timeout=30), "The other connection never took the lock")
+            with mock.patch("ami.main.models_future.tracks.EDIT_LOCK_TIMEOUT_MS", 200):
+                with self.assertRaises(SessionBusy):
+                    merge_occurrences(self.first, [self.second])
+        finally:
+            release.set()
+            holder.join()
+
+        self.assertEqual(Occurrence.objects.filter(pk__in=[self.first.pk, self.second.pk]).count(), 2)
+
+
+class TestFreshEventGuard(TestCase):
+    """The guard refuses already-grouped sessions, and only those.
+
+    Real sessions carry a few detections with no occurrence; refusing those would
+    put most production data out of reach of tracking.
+    """
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=3, interval_minutes=1)
+        create_taxa(self.project)
+        create_occurrences(deployment=self.deployment, num=3)
+        event = self.project.events.first()
+        assert event is not None
+        self.event = event
+
+    def test_orphan_detection_does_not_block_a_run(self):
+        orphan = Detection.objects.filter(source_image__event=self.event).first()
+        assert orphan is not None
+        occurrence = orphan.occurrence
+        orphan.occurrence = None
+        orphan.save(update_fields=["occurrence"])
+        if occurrence:
+            occurrence.delete()
+
+        fresh, reason = event_is_fresh(self.event)
+        self.assertTrue(fresh, reason)
+
+    def test_occurrence_spanning_two_detections_blocks_a_run(self):
+        first, second = list(Detection.objects.filter(source_image__event=self.event)[:2])
+        second.occurrence = first.occurrence
+        second.save(update_fields=["occurrence"])
+
+        fresh, reason = event_is_fresh(self.event)
+        self.assertFalse(fresh)
+        self.assertIn("already span", reason)
+
+
+class TestTrackingTaskResolveEvents(TestCase):
+    """Scope-resolution unit tests for ``TrackingTask._resolve_events``."""
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=2, interval_minutes=1)
+        self.event = self.project.events.first()
+        assert self.event is not None
+
+    def test_resolve_events_from_event_ids(self):
+        task = TrackingTask(logger=logger, event_ids=[self.event.pk])
+        events = task._resolve_events()
+        self.assertEqual([e.pk for e in events], [self.event.pk])
+
+    def test_resolve_events_from_capture_set(self):
+        collection = SourceImageCollection.objects.create(name="Tracking scope", project=self.project)
+        collection.images.set(self.event.captures.all())
+
+        task = TrackingTask(logger=logger, source_image_collection_id=collection.pk)
+        events = task._resolve_events()
+        self.assertEqual([e.pk for e in events], [self.event.pk])
+
+    def test_config_requires_exactly_one_scope(self):
+        with self.assertRaises(pydantic.ValidationError):
+            TrackingTask(logger=logger)
+        with self.assertRaises(pydantic.ValidationError):
+            TrackingTask(logger=logger, event_ids=[self.event.pk], source_image_collection_id=1)
+
+    def test_resolve_events_drops_cross_project_ids(self):
+        # Make a foreign event in a different project; the job project should win.
+        other_project, other_deployment = setup_test_project(reuse=False)
+        create_captures(deployment=other_deployment, num_nights=1, images_per_night=2, interval_minutes=1)
+        foreign_event = other_project.events.first()
+        assert foreign_event is not None
+
+        job = Job.objects.create(
+            name="Tracking scope test",
+            project=self.project,
+            job_type_key="post_processing",
+            params={"task": "tracking", "config": {"event_ids": [self.event.pk, foreign_event.pk]}},
+        )
+        task = TrackingTask(job=job, event_ids=[self.event.pk, foreign_event.pk])
+        events = task._resolve_events()
+        self.assertEqual([e.pk for e in events], [self.event.pk])
+
+
+class TestGeneratedMothLifespans(SimpleTestCase):
+    """The generator has to offer tracking both multi-frame chains and single-frame strays.
+
+    A series where every moth is in every frame cannot show whether tracking knows when to
+    stop a chain, and one with no repeat visitors cannot show that it builds chains at all.
+    """
+
+    def test_moths_span_contiguous_runs_and_transients_appear_once(self):
+        frames = generate_moth_series(
+            num_frames=10,
+            num_moths=3,
+            num_transient_moths=2,
+            min_frames_per_moth=4,
+            save_images=False,
+        )
+
+        frames_by_moth = defaultdict(list)
+        for frame in frames:
+            for box in frame.bounding_boxes:
+                frames_by_moth[box.identifier].append(frame.frame_num)
+
+        self.assertEqual(len(frames_by_moth), 5)
+        for identifier, frame_numbers in frames_by_moth.items():
+            self.assertEqual(
+                frame_numbers,
+                list(range(min(frame_numbers), max(frame_numbers) + 1)),
+                f"Moth {identifier} should be visible for one unbroken run of frames",
+            )
+        spans = sorted(len(frame_numbers) for frame_numbers in frames_by_moth.values())
+        self.assertEqual(spans[:2], [1, 1], "Both transient moths should appear in exactly one frame")
+        self.assertGreaterEqual(spans[2], 4, "Every other moth should stay for at least min_frames_per_moth")
+
+
+class TestTrackingDemoSession(TestCase):
+    """The demo session must reach tracking in the shape it needs, and be rebuilt from it.
+
+    Two properties make the session trackable and both are easy to lose: the captures carry
+    dimensions, without which the matching cost has no image diagonal and skips the
+    transition, and every detection starts on an occurrence of its own, without which
+    ``event_is_fresh`` refuses the event outright.
+    """
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        self.ground_truth = create_tracking_session(
+            self.deployment,
+            taxa_list=create_taxa(self.project),
+            num_frames=8,
+            num_moths=3,
+            num_transient_moths=2,
+            min_frames_per_moth=4,
+            create_crops=False,
+        )
+        self.event = Event.objects.get(pk=self.ground_truth.event_id)
+
+    def test_session_arrives_ready_to_track(self):
+        self.assertEqual(self.event.captures.count(), self.ground_truth.capture_count)
+        self.assertFalse(self.event.captures.filter(width__isnull=True).exists())
+        self.assertEqual(
+            Occurrence.objects.filter(event=self.event).count(),
+            self.ground_truth.detection_count,
+            "Every detection should start on an occurrence of its own",
+        )
+        fresh, reason = event_is_fresh(self.event)
+        self.assertTrue(fresh, reason)
+
+    def test_tracking_recovers_every_simulated_insect(self):
+        TrackingTask(
+            logger=logger,
+            event_ids=[self.event.pk],
+            require_features=False,
+            cost_threshold=0.4,
+        ).run()
+
+        result = score_tracking_run(self.ground_truth)
+        self.assertEqual(result["exactly_recovered"], result["simulated_insects"], result)
+
+
+class TestIdentificationsSurviveMerging(TestCase):
+    """Merging chains must not destroy a person's taxonomic work.
+
+    ``Identification.occurrence`` cascades on delete, and consolidating a chain
+    deletes every occurrence except the keeper. A session that has never been
+    tracked can still have been reviewed, so identifications have to be moved to
+    the keeper before the occurrences holding them are removed.
+    """
+
+    def setUp(self) -> None:
+        self.project, self.deployment = setup_test_project(reuse=False)
+        create_captures(deployment=self.deployment, num_nights=1, images_per_night=5, interval_minutes=1)
+        create_taxa(self.project)
+        create_occurrences(deployment=self.deployment, num=6)
+
+        self.event = self.project.events.first()
+        assert self.event is not None
+        _give_captures_dimensions(list(self.event.captures.all()))
+
+        self.user = UserFactory()
+        taxon = Taxon.objects.filter(occurrences__event=self.event).first() or Taxon.objects.first()
+        assert taxon is not None
+        # Identify every occurrence in the event. The keeper is the chain's first
+        # occurrence, so identifying only one would pass by luck roughly as often
+        # as the chain is long.
+        self.identified = list(Occurrence.objects.filter(event=self.event))
+        self.assertGreater(len(self.identified), 1, "Need several occurrences for a merge to happen")
+        for occurrence in self.identified:
+            Identification.objects.create(user=self.user, taxon=taxon, occurrence=occurrence)
+        self.identification_count = Identification.objects.filter(occurrence__event=self.event).count()
+
+    def test_identifications_move_to_the_keeper_instead_of_being_deleted(self):
+        task = TrackingTask(
+            logger=logger,
+            event_ids=[self.event.pk],
+            require_features=False,
+            cost_threshold=0.5,
+            # The guard would refuse this event; the point of the test is what happens
+            # when an operator turns it off, which the admin form allows.
+            skip_if_human_identifications=False,
+        )
+        task.run()
+
+        merged_away = Occurrence.objects.filter(pk__in=[o.pk for o in self.identified]).count()
+        self.assertLess(merged_away, len(self.identified), "This test only means something if a merge occurred")
+
+        self.assertEqual(
+            Identification.objects.filter(user=self.user).count(),
+            self.identification_count,
+            "Every identification must survive the merge",
+        )
+        self.assertFalse(
+            Identification.objects.filter(user=self.user, occurrence__isnull=True).exists(),
+            "No identification should be left without an occurrence",
+        )
+        surviving = Occurrence.objects.filter(event=self.event).values_list("pk", flat=True)
+        self.assertTrue(
+            set(Identification.objects.filter(user=self.user).values_list("occurrence_id", flat=True))
+            <= set(surviving),
+            "Every identification must point at an occurrence that still exists",
+        )
+
+    def _tracking_job(self) -> Job:
+        job = Job.objects.create(
+            name="Tracking summary test",
+            project=self.project,
+            job_type_key="post_processing",
+            params={"task": "tracking", "config": {"event_ids": [self.event.pk]}},
+        )
+        job.progress.add_stage("Post-processing", key="post_processing")
+        job.save()
+        return job
+
+    def _stage_params(self, job: Job) -> dict[str, typing.Any]:
+        job.refresh_from_db()
+        return {param.name: param.value for param in job.progress.get_stage("post_processing").params}
+
+    def test_a_run_that_skips_every_session_says_why_in_the_job(self):
+        """A run whose sessions were all skipped still succeeds, so the job details must say
+        that nothing was tracked and why, instead of looking like a run that did the work."""
+        job = self._tracking_job()
+        TrackingTask(job=job, event_ids=[self.event.pk], require_features=False, cost_threshold=0.5).run()
+
+        params = self._stage_params(job)
+        self.assertEqual(params["Sessions tracked"], 0)
+        self.assertEqual(
+            params["Result"], "Nothing was tracked: 1 session(s) skipped (1 because it has human identifications)."
+        )
+
+    def test_a_retried_run_that_tracks_replaces_the_nothing_tracked_line(self):
+        """A retry keeps text stage params, so a run that tracks must overwrite the earlier
+        "Nothing was tracked" line rather than leave it beside a non-zero count."""
+        job = self._tracking_job()
+        TrackingTask(job=job, event_ids=[self.event.pk], require_features=False, cost_threshold=0.5).run()
+        self.assertTrue(self._stage_params(job)["Result"].startswith("Nothing was tracked"))
+
+        job.progress.reset()
+        job.save()
+        TrackingTask(
+            job=job,
+            event_ids=[self.event.pk],
+            require_features=False,
+            cost_threshold=0.5,
+            skip_if_human_identifications=False,
+        ).run()
+
+        params = self._stage_params(job)
+        self.assertEqual(params["Sessions tracked"], 1)
+        self.assertEqual(params["Result"], "Tracked 1 session(s).")
diff --git a/ami/ml/post_processing/tracking_evaluation.py b/ami/ml/post_processing/tracking_evaluation.py
new file mode 100644
index 000000000..8a0776e77
--- /dev/null
+++ b/ami/ml/post_processing/tracking_evaluation.py
@@ -0,0 +1,593 @@
+"""Score a tracking run against tracks a person has confirmed.
+
+Ground truth is the set of occurrences whose grouping a person confirmed: each one is taken
+to be a complete and accurate track. Nothing is known about detections outside those tracks,
+so every metric here is computed only over the detections that belong to a confirmed track.
+In particular, a predicted detection outside every confirmed track is never an identity false
+positive, which makes ID precision, ID recall and IDF1 the same number here.
+
+This module imports nothing from Django, so it also runs outside Antenna on exported CSVs:
+
+    python -m ami.ml.post_processing.tracking_evaluation --ground-truth gt.csv --predictions pred.csv
+"""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import csv
+import dataclasses
+import datetime
+import json
+import sys
+import typing
+from collections.abc import Hashable, Iterable, Mapping
+
+DetectionId = Hashable
+TrackId = Hashable
+
+TRUE_VALUES = {"true", "1", "yes", "t", "y"}
+
+# Share of a confirmed track's detections held by one predicted track, at or above which it is
+# mostly tracked, and below which it is mostly lost; in between it is partly tracked.
+MOSTLY_TRACKED = 0.8
+MOSTLY_LOST = 0.2
+
+REPORT_NOTES = [
+    "Headline: IDF1, the share of confirmed detections whose predicted track is the one matched "
+    "one-to-one to their confirmed track. Predicted detections outside confirmed tracks are not counted "
+    "as errors, because the confirmed tracks are only part of the session.",
+    "Weighting: IDF1 and link scores count each detection or link once, so long tracks weigh more; "
+    "pairwise scores grow with the square of track length; track counts and means count each "
+    "confirmed track once.",
+]
+
+
+def _sort_key(value: typing.Any) -> tuple:
+    """Order ids of mixed types deterministically: numbers before strings."""
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return (0, value, "")
+    return (1, 0, str(value))
+
+
+def _ratio(numerator: int, denominator: int) -> float | None:
+    """A ratio, or None when it is undefined because nothing was counted."""
+    return numerator / denominator if denominator else None
+
+
+def _f1(precision: float | None, recall: float | None) -> float | None:
+    if precision is None or recall is None:
+        return None
+    if precision + recall == 0:
+        return 0.0
+    return 2 * precision * recall / (precision + recall)
+
+
+def _pairs(n: int) -> int:
+    return n * (n - 1) // 2
+
+
+@dataclasses.dataclass
+class GroundTruthTrackScore:
+    """How one confirmed track was rebuilt.
+
+    ``fragments`` is the number of predicted tracks its detections were split across (1 is
+    best); ``completeness`` is the share of its detections held by the largest of them.
+    """
+
+    track_id: TrackId
+    length: int
+    fragments: int
+    completeness: float
+    exactly_recovered: bool
+    # How many times the predicted track changes between consecutive detections, in time order.
+    id_switches: int
+
+
+@dataclasses.dataclass
+class PredictedTrackScore:
+    """One predicted track that holds at least one detection from a confirmed track.
+
+    ``length`` counts only its detections in confirmed tracks. ``purity`` is the share of
+    those held by the confirmed track it overlaps most; ``ground_truth_tracks`` above 1 is
+    a merge of different insects. ``first_detection_id`` is its earliest detection among
+    those, a detection id rather than a track id, so it cannot be confused with the
+    occurrence ids that name confirmed tracks.
+    """
+
+    first_detection_id: DetectionId
+    length: int
+    ground_truth_tracks: int
+    purity: float
+
+
+@dataclasses.dataclass
+class TrackingEvaluation:
+    """Scores of predicted tracks against confirmed tracks, over detections in confirmed tracks.
+
+    Precision and recall are None when their denominator is zero, for example precision when
+    no two detections were predicted to be the same insect.
+    """
+
+    ground_truth_tracks: int
+    detections: int
+    ground_truth_singletons: int
+    predicted_tracks: int
+    predicted_singletons: int
+
+    # The headline score, IDF1 (Ristani et al. 2016), from a one-to-one matching of confirmed
+    # and predicted tracks that keeps as many detections as possible in their matched track.
+    idf1: float | None
+    id_true_positives: int
+    id_switches: int
+    mostly_tracked: int
+    partly_tracked: int
+    mostly_lost: int
+
+    # Every unordered pair of detections: is it the same insect in both?
+    pairwise_true_positives: int
+    pairwise_predicted: int
+    pairwise_ground_truth: int
+    pairwise_precision: float | None
+    pairwise_recall: float | None
+    pairwise_f1: float | None
+
+    # Links between detections that follow each other in time within a track.
+    links_correct: int
+    links_predicted: int
+    links_ground_truth: int
+    link_precision: float | None
+    link_recall: float | None
+    link_f1: float | None
+
+    merges: int
+    fragmented_tracks: int
+    exactly_recovered: int
+    mean_completeness: float | None
+    mean_purity: float | None
+
+    ground_truth_track_scores: list[GroundTruthTrackScore]
+    predicted_track_scores: list[PredictedTrackScore]
+
+    def to_dict(self, include_tracks: bool = True) -> dict[str, typing.Any]:
+        result = dataclasses.asdict(self)
+        if not include_tracks:
+            result.pop("ground_truth_track_scores")
+            result.pop("predicted_track_scores")
+        return result
+
+    def summary_lines(self) -> list[str]:
+        """The headline numbers as short human-readable lines."""
+
+        def fmt(value: float | None) -> str:
+            return "n/a" if value is None else f"{value:.3f}"
+
+        return [
+            f"IDF1 {fmt(self.idf1)}  ({self.id_true_positives}/{self.detections} detections in their "
+            f"matched predicted track)",
+            f"Mostly tracked {self.mostly_tracked}  partly tracked {self.partly_tracked}  "
+            f"mostly lost {self.mostly_lost}  ID switches {self.id_switches}",
+            f"Confirmed tracks: {self.ground_truth_tracks} ({self.ground_truth_singletons} single-detection), "
+            f"detections: {self.detections}",
+            f"Predicted tracks over those detections: {self.predicted_tracks} "
+            f"({self.predicted_singletons} single-detection)",
+            f"Pairwise precision {fmt(self.pairwise_precision)}  recall {fmt(self.pairwise_recall)}  "
+            f"F1 {fmt(self.pairwise_f1)}  ({self.pairwise_true_positives}/{self.pairwise_predicted} predicted, "
+            f"{self.pairwise_ground_truth} true pairs)",
+            f"Link precision {fmt(self.link_precision)}  recall {fmt(self.link_recall)}  F1 {fmt(self.link_f1)}  "
+            f"({self.links_correct}/{self.links_predicted} predicted, {self.links_ground_truth} true links)",
+            f"Exactly recovered: {self.exactly_recovered}/{self.ground_truth_tracks}  "
+            f"fragmented: {self.fragmented_tracks}  merges: {self.merges}",
+            f"Mean completeness {fmt(self.mean_completeness)}  mean purity {fmt(self.mean_purity)}",
+        ]
+
+
+def _time_ordered(detection_ids: Iterable[DetectionId], timestamps: Mapping[DetectionId, typing.Any]) -> list:
+    """Detections in capture order; the detection id breaks ties so the order is deterministic."""
+    return sorted(detection_ids, key=lambda d: (timestamps[d], _sort_key(d)))
+
+
+def _consecutive_links(tracks: Mapping[TrackId, list[DetectionId]]) -> set[frozenset]:
+    links: set[frozenset] = set()
+    for members in tracks.values():
+        for first, second in zip(members, members[1:]):
+            links.add(frozenset((first, second)))
+    return links
+
+
+def _best_assignment_total(weights: list[list[int]]) -> int:
+    """The largest total weight of a one-to-one matching of rows to columns (Hungarian method).
+
+    scipy's ``linear_sum_assignment`` does this, but scipy is not a dependency of this module.
+    """
+    infinity = float("inf")
+    if len(weights) > len(weights[0]):
+        weights = [list(column) for column in zip(*weights)]
+    rows, columns = len(weights), len(weights[0])
+    # Potentials and matches are 1-indexed; column 0 is a free slot the method starts from.
+    row_potential = [0] * (rows + 1)
+    column_potential = [0] * (columns + 1)
+    row_of_column = [0] * (columns + 1)
+    previous_column = [0] * (columns + 1)
+    for row in range(1, rows + 1):
+        row_of_column[0] = row
+        column = 0
+        slack = [infinity] * (columns + 1)
+        used = [False] * (columns + 1)
+        while row_of_column[column]:
+            used[column] = True
+            current_row, delta, next_column = row_of_column[column], infinity, 0
+            for j in range(1, columns + 1):
+                if used[j]:
+                    continue
+                cost = -weights[current_row - 1][j - 1] - row_potential[current_row] - column_potential[j]
+                if cost < slack[j]:
+                    slack[j], previous_column[j] = cost, column
+                if slack[j] < delta:
+                    delta, next_column = slack[j], j
+            for j in range(columns + 1):
+                if used[j]:
+                    row_potential[row_of_column[j]] += delta
+                    column_potential[j] -= delta
+                else:
+                    slack[j] -= delta
+            column = next_column
+        while column:
+            row_of_column[column] = row_of_column[previous_column[column]]
+            column = previous_column[column]
+    return sum(weights[row_of_column[j] - 1][j - 1] for j in range(1, columns + 1) if row_of_column[j])
+
+
+def _identity_true_positives(overlap: Mapping[tuple[TrackId, TrackId], int]) -> int:
+    """Detections kept in their track by the best one-to-one matching of confirmed to predicted tracks.
+
+    The matching is solved separately for each group of tracks connected by shared detections,
+    which keeps every matrix small.
+    """
+    parent: dict[tuple, tuple] = {}
+
+    def root(node: tuple) -> tuple:
+        while parent.setdefault(node, node) != node:
+            node = parent[node]
+        return node
+
+    for gt_id, pred_id in overlap:
+        parent[root(("gt", gt_id))] = root(("pred", pred_id))
+    groups: dict[tuple, list[tuple[TrackId, TrackId]]] = collections.defaultdict(list)
+    for key in overlap:
+        groups[root(("gt", key[0]))].append(key)
+
+    total = 0
+    for keys in groups.values():
+        gt_ids = sorted({gt_id for gt_id, _ in keys}, key=_sort_key)
+        pred_ids = sorted({pred_id for _, pred_id in keys}, key=_sort_key)
+        total += _best_assignment_total([[overlap.get((g, p), 0) for p in pred_ids] for g in gt_ids])
+    return total
+
+
+def evaluate_tracks(
+    ground_truth: Mapping[DetectionId, TrackId],
+    predictions: Mapping[DetectionId, TrackId],
+    timestamps: Mapping[DetectionId, typing.Any],
+) -> TrackingEvaluation:
+    """Score predicted tracks against confirmed tracks.
+
+    ``ground_truth`` and ``predictions`` map a detection id to the id of the track it is in;
+    ``timestamps`` gives each ground-truth detection a sortable capture time. Only detections
+    in ``ground_truth`` are scored. A predicted track is cut down to those detections, so its
+    links are between consecutive scored detections; a scored detection missing from
+    ``predictions`` counts as a predicted track of its own.
+    """
+    scored = list(ground_truth)
+    missing_times = [d for d in scored if timestamps.get(d) is None]
+    if missing_times:
+        raise ValueError(f"{len(missing_times)} detection(s) have no timestamp, e.g. {missing_times[:3]}")
+
+    # Private sentinel keys keep an unpredicted detection from sharing a track with anything.
+    predicted_track_of = {d: predictions[d] if d in predictions else ("__unpredicted__", d) for d in scored}
+
+    gt_tracks: dict[TrackId, list[DetectionId]] = collections.defaultdict(list)
+    pred_tracks: dict[TrackId, list[DetectionId]] = collections.defaultdict(list)
+    for d in _time_ordered(scored, timestamps):
+        gt_tracks[ground_truth[d]].append(d)
+        pred_tracks[predicted_track_of[d]].append(d)
+
+    overlap: collections.Counter = collections.Counter((ground_truth[d], predicted_track_of[d]) for d in scored)
+    pred_by_gt: dict[TrackId, collections.Counter] = collections.defaultdict(collections.Counter)
+    gt_by_pred: dict[TrackId, collections.Counter] = collections.defaultdict(collections.Counter)
+    for (gt_id, pred_id), n in overlap.items():
+        pred_by_gt[gt_id][pred_id] = n
+        gt_by_pred[pred_id][gt_id] = n
+
+    pairwise_tp = sum(_pairs(n) for n in overlap.values())
+    pairwise_pred = sum(_pairs(len(m)) for m in pred_tracks.values())
+    pairwise_gt = sum(_pairs(len(m)) for m in gt_tracks.values())
+    pairwise_precision = _ratio(pairwise_tp, pairwise_pred)
+    pairwise_recall = _ratio(pairwise_tp, pairwise_gt)
+
+    gt_links = _consecutive_links(gt_tracks)
+    pred_links = _consecutive_links(pred_tracks)
+    links_correct = len(gt_links & pred_links)
+    link_precision = _ratio(links_correct, len(pred_links))
+    link_recall = _ratio(links_correct, len(gt_links))
+
+    id_true_positives = _identity_true_positives(overlap)
+
+    gt_scores = []
+    for gt_id in sorted(gt_tracks, key=_sort_key):
+        pieces = pred_by_gt[gt_id]
+        length = len(gt_tracks[gt_id])
+        (largest_pred, largest), *_ = sorted(pieces.items(), key=lambda kv: (-kv[1], _sort_key(kv[0])))
+        gt_scores.append(
+            GroundTruthTrackScore(
+                track_id=gt_id,
+                length=length,
+                fragments=len(pieces),
+                completeness=largest / length,
+                exactly_recovered=len(pieces) == 1 and len(gt_by_pred[largest_pred]) == 1,
+                id_switches=sum(
+                    predicted_track_of[a] != predicted_track_of[b]
+                    for a, b in zip(gt_tracks[gt_id], gt_tracks[gt_id][1:])
+                ),
+            )
+        )
+
+    pred_scores = []
+    # Listed in the order of the ids they are reported under.
+    for pred_id in sorted(pred_tracks, key=lambda p: _sort_key(pred_tracks[p][0])):
+        spans = gt_by_pred[pred_id]
+        length = len(pred_tracks[pred_id])
+        pred_scores.append(
+            PredictedTrackScore(
+                first_detection_id=pred_tracks[pred_id][0],
+                length=length,
+                ground_truth_tracks=len(spans),
+                purity=max(spans.values()) / length,
+            )
+        )
+
+    return TrackingEvaluation(
+        ground_truth_tracks=len(gt_tracks),
+        detections=len(scored),
+        ground_truth_singletons=sum(1 for m in gt_tracks.values() if len(m) == 1),
+        predicted_tracks=len(pred_tracks),
+        predicted_singletons=sum(1 for m in pred_tracks.values() if len(m) == 1),
+        idf1=_ratio(id_true_positives, len(scored)),
+        id_true_positives=id_true_positives,
+        id_switches=sum(s.id_switches for s in gt_scores),
+        mostly_tracked=sum(1 for s in gt_scores if s.completeness >= MOSTLY_TRACKED),
+        partly_tracked=sum(1 for s in gt_scores if MOSTLY_LOST <= s.completeness < MOSTLY_TRACKED),
+        mostly_lost=sum(1 for s in gt_scores if s.completeness < MOSTLY_LOST),
+        pairwise_true_positives=pairwise_tp,
+        pairwise_predicted=pairwise_pred,
+        pairwise_ground_truth=pairwise_gt,
+        pairwise_precision=pairwise_precision,
+        pairwise_recall=pairwise_recall,
+        pairwise_f1=_f1(pairwise_precision, pairwise_recall),
+        links_correct=links_correct,
+        links_predicted=len(pred_links),
+        links_ground_truth=len(gt_links),
+        link_precision=link_precision,
+        link_recall=link_recall,
+        link_f1=_f1(link_precision, link_recall),
+        merges=sum(1 for s in pred_scores if s.ground_truth_tracks > 1),
+        fragmented_tracks=sum(1 for s in gt_scores if s.fragments > 1),
+        exactly_recovered=sum(1 for s in gt_scores if s.exactly_recovered),
+        mean_completeness=(sum(s.completeness for s in gt_scores) / len(gt_scores)) if gt_scores else None,
+        mean_purity=(sum(s.purity for s in pred_scores) / len(pred_scores)) if pred_scores else None,
+        ground_truth_track_scores=gt_scores,
+        predicted_track_scores=pred_scores,
+    )
+
+
+def _median(values: list[int]) -> float | None:
+    if not values:
+        return None
+    ordered = sorted(values)
+    middle = len(ordered) // 2
+    return float(ordered[middle]) if len(ordered) % 2 else (ordered[middle - 1] + ordered[middle]) / 2
+
+
+@dataclasses.dataclass
+class TrackSetProfile:
+    """Length and crowding of a set of tracks.
+
+    ``mean_detections_per_capture`` averages, over every detection in the set, how many
+    detections share its capture: a measure of how crowded the moments these tracks cover are.
+    """
+
+    tracks: int
+    singletons: int
+    median_length: float | None
+    mean_length: float | None
+    max_length: int | None
+    mean_detections_per_capture: float | None
+
+
+@dataclasses.dataclass
+class ConfirmedSetBias:
+    """The confirmed tracks next to every predicted track of the same sessions.
+
+    People tend to confirm short, clean tracks in quiet moments first, so the confirmed tracks
+    may not represent the session. The scores above hold only for tracks like these.
+    """
+
+    confirmed: TrackSetProfile
+    session: TrackSetProfile
+
+    def to_dict(self) -> dict[str, typing.Any]:
+        return dataclasses.asdict(self)
+
+    def summary_lines(self) -> list[str]:
+        def fmt(value: float | None) -> str:
+            return "n/a" if value is None else f"{value:.1f}"
+
+        confirmed, session = self.confirmed, self.session
+        return [
+            "Confirmed tracks vs the whole session (all predicted tracks):",
+            f"  tracks {confirmed.tracks} vs {session.tracks}  single-detection {confirmed.singletons} vs "
+            f"{session.singletons}",
+            f"  length median {fmt(confirmed.median_length)} vs {fmt(session.median_length)}  "
+            f"mean {fmt(confirmed.mean_length)} vs {fmt(session.mean_length)}  "
+            f"max {confirmed.max_length} vs {session.max_length}",
+            f"  detections per capture {fmt(confirmed.mean_detections_per_capture)} vs "
+            f"{fmt(session.mean_detections_per_capture)}",
+        ]
+
+
+def describe_confirmed_set(
+    ground_truth: Mapping[DetectionId, TrackId],
+    predictions: Mapping[DetectionId, TrackId],
+    captures: Mapping[DetectionId, Hashable],
+) -> ConfirmedSetBias:
+    """Profile the confirmed tracks against every predicted track of the sessions they come from.
+
+    ``predictions`` must cover every detection of those sessions, and ``captures`` gives each
+    of them its capture id. Unlike the scores, this looks beyond the confirmed tracks.
+    """
+    missing = [d for d in ground_truth if d not in captures]
+    if missing:
+        raise ValueError(f"{len(missing)} confirmed detection(s) have no capture, e.g. {missing[:3]}")
+    per_capture = collections.Counter(captures.values())
+
+    def profile(track_of: Mapping[DetectionId, TrackId]) -> TrackSetProfile:
+        lengths = list(collections.Counter(track_of.values()).values())
+        crowding = [per_capture[captures[d]] for d in track_of if d in captures]
+        return TrackSetProfile(
+            tracks=len(lengths),
+            singletons=sum(1 for n in lengths if n == 1),
+            median_length=_median(lengths),
+            mean_length=(sum(lengths) / len(lengths)) if lengths else None,
+            max_length=max(lengths) if lengths else None,
+            mean_detections_per_capture=(sum(crowding) / len(crowding)) if crowding else None,
+        )
+
+    return ConfirmedSetBias(confirmed=profile(ground_truth), session=profile(predictions))
+
+
+def tracks_from_links(
+    detection_ids: Iterable[DetectionId], links: Iterable[tuple[DetectionId, DetectionId]]
+) -> dict[DetectionId, DetectionId]:
+    """Group detections joined by ``(earlier, later)`` links into tracks.
+
+    Returns detection id -> track id, where a track's id is its first detection. Each
+    detection has at most one link in and one out, as tracking produces; a detection with no
+    links is a track of its own.
+    """
+    next_of: dict[DetectionId, DetectionId] = {}
+    has_previous: set[DetectionId] = set()
+    for earlier, later in links:
+        if earlier in next_of or later in has_previous:
+            raise ValueError(f"Detection linked more than once: {earlier} -> {later}")
+        next_of[earlier] = later
+        has_previous.add(later)
+
+    track_of: dict[DetectionId, DetectionId] = {}
+    all_ids = set(detection_ids) | set(next_of) | has_previous
+    for start in sorted(all_ids - has_previous, key=_sort_key):
+        current: DetectionId | None = start
+        while current is not None and current not in track_of:
+            track_of[current] = start
+            current = next_of.get(current)
+    unreached = all_ids - set(track_of)
+    if unreached:
+        raise ValueError(f"Links form a cycle through {sorted(unreached, key=_sort_key)[:3]}")
+    return track_of
+
+
+# CSV adapter: the tracks export writes one row per detection, grouped by occurrence.
+
+
+def _parse_timestamps(raw: Mapping[str, str]) -> dict[str, datetime.datetime]:
+    """Parse ISO capture times, raising ValueError for blank, unreadable or mixed-zone values.
+
+    Every value must parse, and all must be timezone-aware or all naive, because Python
+    cannot order a mix of datetimes and strings, or of naive and aware datetimes.
+    """
+    parsed: dict[str, datetime.datetime] = {}
+    blank: list[str] = []
+    unreadable: list[str] = []
+    for detection_id, value in raw.items():
+        value = (value or "").strip()
+        if not value:
+            blank.append(detection_id)
+            continue
+        try:
+            parsed[detection_id] = datetime.datetime.fromisoformat(value)
+        except ValueError:
+            unreadable.append(detection_id)
+    if blank:
+        raise ValueError(f"{len(blank)} confirmed detection(s) have no timestamp, e.g. detection_id {blank[:3]}")
+    if unreadable:
+        raise ValueError(
+            f"{len(unreadable)} confirmed detection(s) have a timestamp that is not ISO 8601, "
+            f"e.g. detection_id {unreadable[:3]}"
+        )
+    aware = {detection_id for detection_id, value in parsed.items() if value.utcoffset() is not None}
+    if aware and len(aware) < len(parsed):
+        naive = sorted(set(parsed) - aware)
+        raise ValueError(
+            "Timestamps mix timezone-aware and naive values; "
+            f"e.g. aware detection_id {sorted(aware)[:3]}, naive detection_id {naive[:3]}"
+        )
+    return parsed
+
+
+def read_tracks_csv(path: str) -> list[dict[str, str]]:
+    with open(path, newline="") as handle:
+        rows = list(csv.DictReader(handle))
+    required = {"occurrence_id", "detection_id", "timestamp"}
+    if rows and not required <= set(rows[0]):
+        raise ValueError(f"{path} is missing columns {sorted(required - set(rows[0]))}")
+    return rows
+
+
+def evaluate_csv_files(ground_truth_path: str, predictions_path: str) -> TrackingEvaluation:
+    """Score a predictions CSV against the confirmed tracks in a ground-truth CSV.
+
+    Both files use the tracks export format. Ground truth is every row whose
+    ``grouping_verified`` is true, grouped by ``occurrence_id``; predictions are every row of
+    the second file, grouped the same way. Capture order comes from ``timestamp``, then
+    ``frame_index`` when present.
+    """
+    ground_truth: dict[str, str] = {}
+    raw_times: dict[str, str] = {}
+    frame_indexes: dict[str, int] = {}
+    for row in read_tracks_csv(ground_truth_path):
+        if (row.get("grouping_verified") or "").strip().lower() not in TRUE_VALUES:
+            continue
+        detection_id = row["detection_id"]
+        ground_truth[detection_id] = row["occurrence_id"]
+        raw_times[detection_id] = row["timestamp"]
+        frame_index = (row.get("frame_index") or "").strip()
+        frame_indexes[detection_id] = int(frame_index) if frame_index.lstrip("-").isdigit() else -1
+    timestamps = {
+        detection_id: (parsed, frame_indexes[detection_id])
+        for detection_id, parsed in _parse_timestamps(raw_times).items()
+    }
+    predictions = {row["detection_id"]: row["occurrence_id"] for row in read_tracks_csv(predictions_path)}
+    return evaluate_tracks(ground_truth, predictions, timestamps)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Score predicted tracks against confirmed tracks (tracks CSVs).")
+    parser.add_argument("--ground-truth", required=True, help="Tracks CSV; rows with grouping_verified=true count.")
+    parser.add_argument("--predictions", required=True, help="Tracks CSV of the run to score.")
+    parser.add_argument("--format", choices=["text", "json"], default="text")
+    parser.add_argument("--per-track", action="store_true", help="Include per-track scores in JSON output.")
+    args = parser.parse_args(argv)
+
+    try:
+        result = evaluate_csv_files(args.ground_truth, args.predictions)
+    except (OSError, ValueError) as error:
+        parser.exit(2, f"error: {error}\n")
+    if args.format == "json":
+        json.dump(result.to_dict(include_tracks=args.per_track), sys.stdout, indent=2, default=str)
+        sys.stdout.write("\n")
+    else:
+        sys.stdout.write("\n".join(REPORT_NOTES + result.summary_lines()) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/ami/ml/post_processing/tracking_task.py b/ami/ml/post_processing/tracking_task.py
new file mode 100644
index 000000000..21fa8ec38
--- /dev/null
+++ b/ami/ml/post_processing/tracking_task.py
@@ -0,0 +1,837 @@
+import collections
+import logging
+import math
+import typing
+from collections.abc import Collection, Iterable, Iterator, Sequence
+
+import numpy as np
+import pydantic
+from django.db import transaction
+from django.db.models import Count
+from django.utils import timezone
+
+from ami.main.models import (
+    Classification,
+    Detection,
+    Event,
+    Identification,
+    Occurrence,
+    SourceImage,
+    SourceImageCollection,
+    update_calculated_fields_for_sessions_and_stations,
+    update_occurrence_determination,
+)
+from ami.main.models_future.track_stats import refresh_track_stats_for_ids
+from ami.main.models_future.tracks import lock_sessions
+from ami.ml.models import Algorithm
+from ami.ml.post_processing.base import BasePostProcessingTask
+
+
+class TrackingConfig(pydantic.BaseModel):
+    """Scope and tunables for a tracking run.
+
+    Scope: exactly one of ``source_image_collection_id`` or ``event_ids`` says
+    which sessions to track. A capture set is the bulk path; an explicit event
+    list is what the Events admin page sends.
+    """
+
+    source_image_collection_id: int | None = None
+    event_ids: list[int] = []
+
+    # Maximum matching cost between two detections in consecutive captures. The cost
+    # sums (1 - cosine similarity of embeddings), (1 - IoU), (1 - box area ratio) and
+    # (centre distance / image diagonal), so a lower threshold links only detections
+    # that barely moved and look alike.
+    # WARNING: the default is calibrated against synthetic features in tests. Tune it
+    # per dataset, and raise it when running without embeddings (see require_features).
+    cost_threshold: float = 0.2
+
+    # When True, a pair of detections is only considered if both carry a feature
+    # embedding. When False, pairs without embeddings are still matched on geometry
+    # alone (the appearance term is dropped, which makes matching more permissive) —
+    # this is what lets tracking run on data processed before embeddings were stored.
+    require_features: bool = True
+
+    skip_if_human_identifications: bool = True
+    require_completely_processed_session: bool = False
+
+    # v1 only operates on fresh data: every detection has its own auto-created
+    # occurrence (1:1) and no chain links exist yet. Re-tracking previously-tracked
+    # data is a v2 concern (see #1272 for the incremental append/prepend plan).
+    require_fresh_event: bool = True
+
+    # Which feature extractor's embeddings to compare. Left unset, the task infers it
+    # when exactly one algorithm produced embeddings for the event.
+    feature_extraction_algorithm_id: int | None = None
+
+    @pydantic.root_validator(skip_on_failure=True)
+    def _exactly_one_scope(cls, values: dict) -> dict:
+        scopes = [values.get("source_image_collection_id"), values.get("event_ids") or None]
+        if sum(s is not None for s in scopes) != 1:
+            raise ValueError("Provide exactly one of source_image_collection_id or event_ids")
+        return values
+
+    class Config:
+        extra = "forbid"
+
+
+def cosine_similarity(v1: Iterable[float], v2: Iterable[float]) -> float:
+    a = np.array(v1)
+    b = np.array(v2)
+    sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
+    return float(np.clip(sim, 0.0, 1.0))
+
+
+def iou(bb1, bb2) -> float:
+    xA = max(bb1[0], bb2[0])
+    yA = max(bb1[1], bb2[1])
+    xB = min(bb1[2], bb2[2])
+    yB = min(bb1[3], bb2[3])
+    inter = max(0, xB - xA + 1) * max(0, yB - yA + 1)
+    area1 = (bb1[2] - bb1[0] + 1) * (bb1[3] - bb1[1] + 1)
+    area2 = (bb2[2] - bb2[0] + 1) * (bb2[3] - bb2[1] + 1)
+    union = area1 + area2 - inter
+    return inter / union if union > 0 else 0.0
+
+
+def box_ratio(bb1, bb2) -> float:
+    area1 = (bb1[2] - bb1[0] + 1) * (bb1[3] - bb1[1] + 1)
+    area2 = (bb2[2] - bb2[0] + 1) * (bb2[3] - bb2[1] + 1)
+    return min(area1, area2) / max(area1, area2)
+
+
+def distance_ratio(bb1, bb2, img_diag: float) -> float:
+    cx1 = (bb1[0] + bb1[2]) / 2
+    cy1 = (bb1[1] + bb1[3]) / 2
+    cx2 = (bb2[0] + bb2[2]) / 2
+    cy2 = (bb2[1] + bb2[3]) / 2
+    dist = math.sqrt((cx2 - cx1) ** 2 + (cy2 - cy1) ** 2)
+    return dist / img_diag if img_diag > 0 else 1.0
+
+
+def image_diagonal(width: int, height: int) -> int:
+    return int(math.ceil(math.sqrt(width**2 + height**2)))
+
+
+def total_cost(f1, f2, bb1, bb2, diag) -> float:
+    """Matching cost between two detections; lower means more likely the same insect.
+
+    The appearance term is dropped when either detection has no embedding, leaving
+    a geometry-only cost. Dropping a non-negative term lowers the total, so a
+    geometry-only run matches more readily at the same threshold.
+    """
+    geometry = (1 - iou(bb1, bb2)) + (1 - box_ratio(bb1, bb2)) + distance_ratio(bb1, bb2, diag)
+    if f1 is None or f2 is None:
+        return geometry
+    return (1 - cosine_similarity(f1, f2)) + geometry
+
+
+def get_unique_feature_algorithm_for_event(event: Event) -> tuple[Algorithm | None, list[Algorithm]]:
+    """
+    Return ``(unique_algorithm, all_candidates)``.
+
+    If exactly one feature-extraction algorithm produced ``features_2048`` for this
+    event, returns that algorithm and a single-element list. Otherwise returns
+    ``(None, candidates)`` so the caller can either skip with a warning or require
+    the operator to pass an explicit ``feature_extraction_algorithm_id``.
+    """
+    algo_ids = (
+        Classification.objects.filter(
+            detection__source_image__event=event,
+            features_2048__isnull=False,
+            algorithm_id__isnull=False,
+        )
+        .values_list("algorithm_id", flat=True)
+        .distinct()
+    )
+    candidates = list(Algorithm.objects.filter(pk__in=list(algo_ids)))
+    if len(candidates) == 1:
+        return candidates[0], candidates
+    return None, candidates
+
+
+def resolve_feature_algorithm(
+    event: Event, config: TrackingConfig, candidates: list[Algorithm] | None = None
+) -> tuple[Algorithm | None, bool, str]:
+    """The feature extractor a tracking run compares embeddings from, and whether it tracks the event.
+
+    Returns ``(algorithm, should_track, note)``. ``algorithm`` is None when the run falls
+    back to geometry alone, and ``note`` says why a run falls back or skips; it is empty
+    when one extractor was configured or found. ``candidates`` are the extractors that
+    produced embeddings: every one in the event unless the caller passes a narrower set.
+    """
+    if config.feature_extraction_algorithm_id is not None:
+        algorithm = Algorithm.objects.filter(pk=config.feature_extraction_algorithm_id).first()
+        if algorithm is None:
+            return (
+                None,
+                False,
+                f"Configured feature_extraction_algorithm_id="
+                f"{config.feature_extraction_algorithm_id} not found; skipping session {event.pk}.",
+            )
+        return algorithm, True, ""
+
+    if candidates is None:
+        _, candidates = get_unique_feature_algorithm_for_event(event)
+    if len(candidates) == 1:
+        return candidates[0], True, ""
+
+    if candidates:
+        candidate_names = [f"#{a.pk} {a.name}" for a in candidates]
+        message = (
+            f"Session {event.pk}: detections classified by {len(candidates)} different "
+            f"feature-extraction algorithms ({candidate_names}). Pass "
+            "feature_extraction_algorithm_id in the job config to disambiguate."
+        )
+    else:
+        message = f"Session {event.pk}: no detections carry feature embeddings."
+
+    if config.require_features:
+        return None, False, f"{message} Skipping."
+    return None, True, f"{message} Matching on bounding-box geometry alone."
+
+
+def event_is_fresh(event: Event) -> tuple[bool, str]:
+    """Has this event's detections already been grouped into chains?
+
+    The guard exists to keep v1 away from events that were already consolidated:
+    merging those again can delete an occurrence that carries identifications.
+    An occurrence spanning more than one detection is the signal for that.
+
+    A detection with no occurrence at all is not that signal — the chain walk
+    creates an occurrence for a chain that has none — so orphans do not block a
+    run. Real sessions routinely carry a handful of them.
+
+    Occurrences are found through their detections' captures, not ``Occurrence.event``,
+    so a track that reaches into this session from another one also counts.
+    """
+    multi_detection_occurrences = (
+        Occurrence.objects.filter(pk__in=Detection.objects.filter(source_image__event=event).values("occurrence_id"))
+        .annotate(_n=Count("detections"))
+        .filter(_n__gt=1)
+        .count()
+    )
+    if multi_detection_occurrences:
+        return False, f"{multi_detection_occurrences} occurrence(s) already span >1 detection"
+
+    return True, ""
+
+
+def event_fully_processed(event: Event, logger: logging.Logger, algorithm: Algorithm) -> bool:
+    total = event.captures.count()
+    processed = (
+        event.captures.filter(
+            detections__classifications__features_2048__isnull=False,
+            detections__classifications__algorithm=algorithm,
+        )
+        .distinct()
+        .count()
+    )
+    if processed < total:
+        logger.info(f"Session {event.pk} not fully processed: {processed}/{total} captures")
+        return False
+    return True
+
+
+def record_tracking_determination(occurrence: Occurrence, algorithm: Algorithm) -> Classification | None:
+    """Leave a terminal classification, attributed to the tracking algorithm, when a merge
+    changed the occurrence's determination, so the history shows what tracking decided.
+
+    Mirrors class masking: the row carries the winning prediction and points back at it via
+    ``applied_to``. It copies the merge's best score; a per-track vote is a separate change.
+    """
+    winner = occurrence.best_prediction
+    if winner is None or winner.detection_id is None or winner.taxon_id is None:
+        return None
+    if winner.algorithm_id == algorithm.pk:
+        return None
+    return Classification.objects.create(
+        detection=winner.detection,
+        taxon=winner.taxon,
+        score=winner.score,
+        terminal=True,
+        algorithm=algorithm,
+        timestamp=timezone.now(),
+        applied_to=winner,
+    )
+
+
+def assign_occurrences_from_detection_chains(
+    source_images: list[SourceImage], logger: logging.Logger, record_as: Algorithm | None = None
+) -> dict[str, int]:
+    """
+    Walk chains via ``Detection.next_detection`` and consolidate each chain into
+    a single occurrence using a merge-into-first strategy:
+
+    - A chain never crosses a session boundary: the walk stops at a detection in another
+      session, and a detection linked from another session starts a chain of its own.
+    - Pick the first existing occurrence in the chain as the keeper.
+    - Reassign every other detection in the chain to the keeper.
+    - Move any identifications off the siblings onto the keeper, then delete them.
+    - If no detection in the chain has an occurrence yet, create one.
+    - With ``record_as`` set, a merge that changes the keeper's determination leaves a
+      classification attributed to that algorithm (see ``record_tracking_determination``).
+    - Leave any chain that reaches a confirmed occurrence exactly as it is. A run holds
+      confirmed detections out of linking, so only a link stored earlier leads here.
+    - Store the track statistics of every occurrence the chains settle on, so the list
+      can sort by them (see ``track_stats.refresh_track_stats_for_ids``).
+
+    Designed for fresh-event input (1:1 detection/occurrence). v2 incremental tracking
+    can reuse this primitive for prepend/append: keeper survives, new detections fold in.
+
+    Returns counters for the caller's stage metrics.
+    """
+    visited: set[int] = set()
+    settled: set[int] = set()
+    created = 0
+    merged = 0
+    identifications_moved = 0
+    determinations_recorded = 0
+    confirmed_chains_skipped = 0
+    existing = Occurrence.objects.filter(detections__source_image__in=source_images).distinct().count()
+
+    # A chain ends at a session boundary. A regroup that splits a track keeps the link
+    # between its pieces, and following it would merge them back into one occurrence.
+    session_of_capture = {image.pk: image.event_id for image in source_images}
+    confirmed = set(
+        Occurrence.objects.filter(
+            detections__source_image__in=source_images, grouping_verified_at__isnull=False
+        ).values_list("pk", flat=True)
+    )
+
+    def session_of(detection: Detection) -> int | None:
+        if detection.source_image_id not in session_of_capture:
+            session_of_capture[detection.source_image_id] = (
+                SourceImage.objects.filter(pk=detection.source_image_id).values_list("event_id", flat=True).first()
+            )
+        return session_of_capture[detection.source_image_id]
+
+    for image in source_images:
+        # Null-marker sentinels (bbox IS NULL) mark a capture as processed; they are not insects.
+        for det in image.detections.valid():
+            if det.pk in visited:
+                continue
+            try:
+                prior: Detection | None = det.previous_detection
+            except Detection.DoesNotExist:
+                prior = None
+            if prior is not None and session_of(prior) == image.event_id:
+                continue
+
+            chain: list[Detection] = []
+            current: Detection | None = det
+            while current and current.pk not in visited:
+                chain.append(current)
+                visited.add(current.pk)
+                current = current.next_detection
+                if current is not None and session_of(current) != image.event_id:
+                    break
+
+            old_occ_ids = {d.occurrence_id for d in chain if d.occurrence_id}
+            all_assigned = all(d.occurrence_id is not None for d in chain)
+
+            # Coherent: every detection assigned and all share one occurrence. Nothing to
+            # change, but it still gets its stats stored below, so a re-run fills in
+            # occurrences that were tracked before the stored fields existed.
+            if len(old_occ_ids) == 1 and all_assigned:
+                settled.update(old_occ_ids)
+                continue
+            if old_occ_ids & confirmed:
+                confirmed_chains_skipped += 1
+                continue
+
+            # Pick keeper: first existing occurrence in chain order.
+            keeper: Occurrence | None = None
+            for d in chain:
+                if d.occurrence_id:
+                    keeper = d.occurrence
+                    break
+
+            previous_determination_id = keeper.determination_id if keeper is not None else None
+            if keeper is None:
+                keeper = Occurrence.objects.create(
+                    event=chain[0].source_image.event,
+                    deployment=chain[0].source_image.deployment,
+                    project=chain[0].source_image.project,
+                )
+                created += 1
+
+            # Reassign chain detections to keeper.
+            for d in chain:
+                if d.occurrence_id != keeper.pk:
+                    d.occurrence = keeper
+                    d.save(update_fields=["occurrence"])
+
+            # Move identifications onto the keeper before deleting the occurrences that
+            # held them. Identification.occurrence CASCADEs, so deleting first destroys a
+            # person's work. A fresh event is not protection: freshness means no chains
+            # exist yet, which says nothing about whether anyone has reviewed the
+            # detections. An untracked-but-reviewed session is ordinary.
+            doomed = old_occ_ids - {keeper.pk}
+            if doomed:
+                identifications_moved += Identification.objects.filter(occurrence_id__in=doomed).update(
+                    occurrence=keeper
+                )
+            for occ_id in doomed:
+                try:
+                    Occurrence.objects.filter(id=occ_id).delete()
+                    merged += 1
+                except Exception as e:
+                    logger.error(f"Failed to delete occurrence {occ_id}: {e}")
+
+            # Only the determination is written, so a column the run did not change is
+            # never overwritten with the value it loaded.
+            if update_occurrence_determination(keeper, save=False):
+                keeper.save(update_determination=False, update_fields=["determination", "determination_score"])
+            if record_as is not None and keeper.determination_id != previous_determination_id:
+                if record_tracking_determination(keeper, record_as) is not None:
+                    determinations_recorded += 1
+            settled.add(keeper.pk)
+
+    # Stored once every determination is settled, since id_agreement is measured against
+    # it, and in batches for the whole event rather than three queries per chain.
+    stats_stored = refresh_track_stats_for_ids(settled)
+
+    new_count = Occurrence.objects.filter(detections__source_image__in=source_images).distinct().count()
+    removed = existing - new_count
+    if removed > 0:
+        logger.info(f"Merged {merged} sibling occurrences into chain keepers (net -{removed}).")
+    if identifications_moved:
+        logger.info(f"Moved {identifications_moved} identification(s) onto chain keepers before merging.")
+    if confirmed_chains_skipped:
+        logger.warning(f"Left {confirmed_chains_skipped} chain(s) that reach a confirmed track as they were.")
+    if determinations_recorded:
+        logger.info(f"Recorded {determinations_recorded} determination change(s) as tracking classifications.")
+    logger.info(
+        f"Materialized {created} new occurrences across {len(source_images)} images. "
+        f"Occurrences before: {existing}, after: {new_count}. Detections processed: {len(visited)}. "
+        f"Track statistics stored for {stats_stored} occurrences."
+    )
+    return {
+        "occurrences_before": existing,
+        "occurrences_after": new_count,
+        "occurrences_created": created,
+        "occurrences_merged": merged,
+        "identifications_moved": identifications_moved,
+        "determinations_recorded": determinations_recorded,
+        "confirmed_chains_skipped": confirmed_chains_skipped,
+    }
+
+
+def nothing_tracked_summary(skip_reasons: collections.Counter[str]) -> str:
+    """The line a job shows when every session in scope was skipped, with the count per reason."""
+    total = sum(skip_reasons.values())
+    reasons = "; ".join(f"{count} because {reason}" for reason, count in skip_reasons.most_common())
+    return f"Nothing was tracked: {total} session(s) skipped ({reasons})."
+
+
+def latest_feature_vectors(detection_ids: Iterable[int], algorithm_id: int) -> dict[int, typing.Any]:
+    """The most recent embedding from one algorithm for each detection given, by detection id.
+
+    Detections without one are left out. One query for the whole batch.
+    """
+    vectors: dict[int, typing.Any] = {}
+    rows = (
+        Classification.objects.filter(
+            detection_id__in=list(detection_ids), algorithm_id=algorithm_id, features_2048__isnull=False
+        )
+        .order_by("-timestamp", "-pk")
+        .values_list("detection_id", "features_2048")
+    )
+    for detection_id, vector in rows:
+        vectors.setdefault(detection_id, vector)
+    return vectors
+
+
+def select_links(
+    current_detections: Sequence[Detection],
+    next_detections: Sequence[Detection],
+    vectors: dict[int, typing.Any],
+    diag: float,
+    cost_threshold: float,
+    require_features: bool = True,
+) -> list[tuple[Detection, Detection, float]]:
+    """The links tracking makes between two adjacent captures, lowest cost first, saving nothing.
+
+    A pair is a candidate when its matching cost is below ``cost_threshold``; with
+    ``require_features``, a detection with no embedding in ``vectors`` never is. Candidates
+    are taken lowest cost first, and each detection is linked at most once on either side.
+    Tracking runs and the session view's link preview both call this, so they cannot differ.
+    """
+    candidates: list[tuple[Detection, Detection, float]] = []
+    for det in current_detections:
+        det_vec = vectors.get(det.pk)
+        if det_vec is None and require_features:
+            continue
+        for nxt in next_detections:
+            nxt_vec = vectors.get(nxt.pk)
+            if nxt_vec is None and require_features:
+                continue
+            cost = total_cost(det_vec, nxt_vec, det.bbox, nxt.bbox, diag)
+            if cost < cost_threshold:
+                candidates.append((det, nxt, cost))
+
+    # Secondary keys (det.pk, nxt.pk) keep tied costs deterministic across runs.
+    candidates.sort(key=lambda x: (x[2], x[0].pk, x[1].pk))
+
+    claimed_current: set[int] = set()
+    claimed_next: set[int] = set()
+    links: list[tuple[Detection, Detection, float]] = []
+    for det, nxt, cost in candidates:
+        if det.pk in claimed_current or nxt.pk in claimed_next:
+            continue
+        claimed_current.add(det.pk)
+        claimed_next.add(nxt.pk)
+        links.append((det, nxt, cost))
+    return links
+
+
+def select_transition_links(
+    current_detections: Sequence[Detection],
+    next_detections: Sequence[Detection],
+    image_width: int,
+    image_height: int,
+    cost_threshold: float,
+    algorithm: Algorithm | None,
+    require_features: bool = True,
+) -> list[tuple[Detection, Detection, float]]:
+    """The links tracking makes between two adjacent captures, reading embeddings but saving nothing."""
+    vectors: dict[int, typing.Any] = {}
+    if algorithm is not None:
+        vectors = latest_feature_vectors([det.pk for det in [*current_detections, *next_detections]], algorithm.pk)
+    return select_links(
+        current_detections,
+        next_detections,
+        vectors,
+        image_diagonal(image_width, image_height),
+        cost_threshold,
+        require_features,
+    )
+
+
+def save_links(links: Iterable[tuple[Detection, Detection, float]], logger: logging.Logger) -> None:
+    """Store each link as ``next_detection``, first detaching any other detection pointing at the target."""
+    for det, nxt, cost in links:
+        # Detach any existing inbound link to `nxt` before reassigning.
+        try:
+            prior: Detection | None = nxt.previous_detection
+        except Detection.DoesNotExist:
+            prior = None
+        if prior is not None:
+            prior.next_detection = None
+            prior.save(update_fields=["next_detection"])
+
+        det.next_detection = nxt
+        det.save(update_fields=["next_detection"])
+        logger.debug(f"Linked detection {det.id} -> {nxt.id} (cost {cost:.4f})")
+
+
+def pair_detections(
+    current_detections: list[Detection],
+    next_detections: list[Detection],
+    image_width: int,
+    image_height: int,
+    cost_threshold: float,
+    algorithm: Algorithm | None,
+    logger: logging.Logger,
+    require_features: bool = True,
+) -> int:
+    """
+    Greedy lowest-cost matching between two adjacent images. Sets `next_detection`
+    on each detection in `current_detections` for the best partner in `next_detections`,
+    if that partner's cost is below `cost_threshold` and not already claimed. The links
+    are chosen by `select_links`; this saves them.
+
+    With ``require_features=False``, detections that carry no embedding are still
+    matched, on geometry alone. Returns the number of links created.
+    """
+    links = select_transition_links(
+        current_detections,
+        next_detections,
+        image_width,
+        image_height,
+        cost_threshold,
+        algorithm,
+        require_features,
+    )
+    save_links(links, logger)
+    return len(links)
+
+
+def iter_transition_links(
+    source_images: Sequence[SourceImage],
+    algorithm: Algorithm | None,
+    config: TrackingConfig,
+    logger: logging.Logger,
+    held_out: Collection[int] = frozenset(),
+) -> Iterator[list[tuple[Detection, Detection, float]] | None]:
+    """Yield the proposed links for each pair of consecutive captures, in order, saving nothing.
+
+    Detections whose ids are in ``held_out`` take no part in the matching on either side.
+    Yields None for a transition skipped because the earlier capture has no dimensions. The
+    generator is lazy, so a caller that saves each transition's links before asking for the
+    next one sees detections as they stand after its own writes.
+    """
+    transitions = len(source_images) - 1
+    for i in range(transitions):
+        cur = source_images[i]
+        nxt = source_images[i + 1]
+        if not cur.width or not cur.height:
+            logger.warning(
+                f"Image {cur.pk} has no dimensions; skipping transition {i + 1}/{transitions} "
+                f"for session {cur.event_id}."
+            )
+            yield None
+            continue
+        yield select_transition_links(
+            [det for det in cur.detections.valid() if det.pk not in held_out],
+            [det for det in nxt.detections.valid() if det.pk not in held_out],
+            image_width=cur.width,
+            image_height=cur.height,
+            cost_threshold=config.cost_threshold,
+            algorithm=algorithm,
+            require_features=config.require_features,
+        )
+
+
+def propose_event_links(
+    event: Event,
+    algorithm: Algorithm | None,
+    config: TrackingConfig,
+    logger: logging.Logger,
+) -> list[tuple[int, int, float]]:
+    """The ``(detection_id, next_detection_id, cost)`` links a tracking run would make in one
+    event, treating every detection as unlinked and writing nothing.
+
+    Tracking runs choose links the same way (``iter_transition_links``), so an evaluation
+    built on this scores what the task would do on the same detections.
+    """
+    source_images = list(event.captures.order_by("timestamp"))
+    links: list[tuple[int, int, float]] = []
+    for transition in iter_transition_links(source_images, algorithm, config, logger):
+        links.extend((det.pk, nxt.pk, cost) for det, nxt, cost in transition or [])
+    return links
+
+
+def assign_occurrences_by_tracking_images(
+    event: Event,
+    logger: logging.Logger,
+    algorithm: Algorithm | None,
+    config: TrackingConfig,
+    progress_cb: typing.Callable[[float], None] | None = None,
+    record_as: Algorithm | None = None,
+) -> dict[str, int]:
+    source_images = list(event.captures.order_by("timestamp"))
+    if len(source_images) < 2:
+        logger.warning(f"Session {event.pk}: not enough images to track ({len(source_images)})")
+        return {}
+
+    transitions = len(source_images) - 1
+    skipped_transitions = 0
+    links = 0
+    # Per-event atomic boundary: a crash mid-event rolls back chain links + occurrence
+    # consolidation for THIS event only, leaving other events in the job intact.
+    with transaction.atomic():
+        # A confirmed track is the ground truth runs are scored against, so a run never
+        # changes one: its detections take no part in linking. See #1272.
+        confirmed = list(
+            Detection.objects.filter(
+                source_image__event=event, occurrence__grouping_verified_at__isnull=False
+            ).values_list("pk", "occurrence_id")
+        )
+        held_out = {detection_id for detection_id, _ in confirmed}
+        confirmed_tracks = len({occurrence_id for _, occurrence_id in confirmed})
+        if confirmed_tracks:
+            logger.info(f"Session {event.pk}: leaving {confirmed_tracks} confirmed occurrence(s) unchanged.")
+
+        transition_links = iter_transition_links(source_images, algorithm, config, logger, held_out=held_out)
+        for i, proposed in enumerate(transition_links):
+            if proposed is None:
+                skipped_transitions += 1
+            else:
+                save_links(proposed, logger)
+                links += len(proposed)
+            if progress_cb:
+                progress_cb((i + 1) / transitions)
+
+        if skipped_transitions:
+            logger.info(
+                f"Session {event.pk}: skipped {skipped_transitions}/{transitions} transitions "
+                "due to missing image dimensions."
+            )
+
+        counters = assign_occurrences_from_detection_chains(source_images, logger, record_as=record_as)
+
+    counters["links_created"] = links
+    counters["confirmed_tracks_left_unchanged"] = confirmed_tracks
+    return counters
+
+
+class TrackingTask(BasePostProcessingTask):
+    """
+    Reconstruct occurrences by tracking detections across consecutive captures using
+    feature embeddings and bbox geometry. Updates each Detection's ``next_detection``
+    link and folds each chain of detections into a single Occurrence.
+    """
+
+    key = "tracking"
+    name = "Occurrence Tracking"
+    config_schema = TrackingConfig
+
+    config: TrackingConfig
+
+    def _resolve_events(self) -> list[Event]:
+        """
+        Return the events to track, from either scope in the config.
+
+        A capture set is flattened to the events its images belong to. When a job is
+        attached, every resolved event must belong to ``job.project``; cross-project
+        IDs are dropped with a warning. That guards against a trigger smuggling event
+        IDs from a project the operator cannot see.
+        """
+        if self.config.source_image_collection_id is not None:
+            collection = SourceImageCollection.objects.filter(pk=self.config.source_image_collection_id).first()
+            if collection is None:
+                raise ValueError(f"Capture set {self.config.source_image_collection_id} not found.")
+            qs = Event.objects.filter(captures__collections=collection).distinct()
+            requested: list[int] | None = None
+        else:
+            requested = list(self.config.event_ids)
+            qs = Event.objects.filter(pk__in=requested)
+
+        if self.job and self.job.project_id:
+            cross_project = list(qs.exclude(project_id=self.job.project_id).values_list("pk", flat=True))
+            if cross_project:
+                self.logger.warning(
+                    f"Dropping {len(cross_project)} event(s) outside job project "
+                    f"{self.job.project_id}: {cross_project}"
+                )
+                qs = qs.filter(project_id=self.job.project_id)
+
+        events = list(qs.order_by("pk").distinct())
+        if requested is not None:
+            missing = set(requested) - {e.pk for e in events}
+            if missing:
+                self.logger.warning(f"Tracking requested {sorted(missing)} but those events were not found.")
+        return events
+
+    def _resolve_algorithm(self, event: Event) -> tuple[Algorithm | None, bool]:
+        """Return ``(algorithm, should_track)`` for one event, logging why a run falls back or skips.
+
+        ``algorithm`` is the feature extractor whose embeddings to compare, or None
+        when the run falls back to geometry alone.
+        """
+        algorithm, should_track, note = resolve_feature_algorithm(event, self.config)
+        if note and should_track:
+            self.logger.info(note)
+        elif note:
+            self.logger.warning(note)
+        return algorithm, should_track
+
+    def run(self) -> None:
+        self.logger.info(f"Tracking starting with config: {self.config.dict()}")
+
+        events = self._resolve_events()
+        total = len(events)
+        self.logger.info(f"Tracking: {total} event(s) in scope")
+
+        totals = {
+            "events_tracked": 0,
+            "events_skipped": 0,
+            "links_created": 0,
+            "occurrences_merged": 0,
+            "confirmed_tracks_left_unchanged": 0,
+        }
+        tracked_event_ids: list[int] = []
+        # Why each session was skipped, so a run that tracks nothing can say so.
+        skip_reasons: collections.Counter[str] = collections.Counter()
+
+        for idx, event in enumerate(events, start=1):
+            self.logger.info(f"Tracking session {idx}/{total} (id={event.pk})")
+            # Each session is checked and tracked under the lock track edits also take, so the
+            # checks see an edit made since the job started and an edit made during the run waits.
+            with transaction.atomic():
+                lock_sessions([event.pk])
+
+                if self.config.require_fresh_event:
+                    fresh, reason = event_is_fresh(event)
+                    if not fresh:
+                        self.logger.info(
+                            f"Skipping session {event.pk}: not fresh ({reason}). "
+                            "v1 only handles 1:1 detection/occurrence input. "
+                            "Re-tracking previously-tracked data lands in v2 (incremental)."
+                        )
+                        totals["events_skipped"] += 1
+                        skip_reasons["it was already tracked or edited"] += 1
+                        continue
+
+                algorithm, should_track = self._resolve_algorithm(event)
+                if not should_track:
+                    totals["events_skipped"] += 1
+                    skip_reasons["it has no embeddings from a single feature extractor to compare"] += 1
+                    continue
+
+                if (
+                    self.config.skip_if_human_identifications
+                    and Occurrence.objects.filter(event=event, identifications__isnull=False).exists()
+                ):
+                    self.logger.info(f"Skipping session {event.pk}: has human identifications.")
+                    totals["events_skipped"] += 1
+                    skip_reasons["it has human identifications"] += 1
+                    continue
+
+                if (
+                    self.config.require_completely_processed_session
+                    and algorithm is not None
+                    and not event_fully_processed(event, logger=self.logger, algorithm=algorithm)
+                ):
+                    self.logger.info(f"Skipping session {event.pk}: not fully processed.")
+                    totals["events_skipped"] += 1
+                    skip_reasons["it is not fully processed"] += 1
+                    continue
+
+                def _stage_progress(p: float, _idx=idx, _total=total) -> None:
+                    # Aggregate per-event progress into overall task progress.
+                    overall = ((_idx - 1) + p) / _total
+                    self.update_progress(overall)
+
+                counters = assign_occurrences_by_tracking_images(
+                    event=event,
+                    logger=self.logger,
+                    algorithm=algorithm,
+                    config=self.config,
+                    record_as=self.algorithm,
+                    progress_cb=_stage_progress,
+                )
+                totals["events_tracked"] += 1
+                tracked_event_ids.append(event.pk)
+                totals["links_created"] += counters.get("links_created", 0)
+                totals["occurrences_merged"] += counters.get("occurrences_merged", 0)
+                totals["confirmed_tracks_left_unchanged"] += counters.get("confirmed_tracks_left_unchanged", 0)
+
+        # Merging occurrences changes the session and station counts, which no save refreshes.
+        # This already runs in a background job, so the station refresh stays inline.
+        update_calculated_fields_for_sessions_and_stations(tracked_event_ids, stations_async=False)
+
+        metrics: dict[str, typing.Any] = {
+            "Sessions tracked": totals["events_tracked"],
+            "Sessions skipped": totals["events_skipped"],
+            "Detection links created": totals["links_created"],
+            "Occurrences merged": totals["occurrences_merged"],
+            "Confirmed occurrences left unchanged": totals["confirmed_tracks_left_unchanged"],
+        }
+        # The job still succeeds, so without this line a run that skipped every session
+        # looks the same in the job details as one that did the work. It is written on every
+        # run because a retry keeps text params, and a stale line would contradict the counts.
+        if totals["events_tracked"]:
+            metrics["Result"] = f"Tracked {totals['events_tracked']} session(s)."
+            if left_unchanged := totals["confirmed_tracks_left_unchanged"]:
+                metrics["Result"] += f" Left {left_unchanged} confirmed occurrence(s) unchanged."
+        elif skip_reasons:
+            metrics["Result"] = nothing_tracked_summary(skip_reasons)
+            self.logger.warning(metrics["Result"])
+        else:
+            metrics["Result"] = "Nothing was tracked: no sessions in scope."
+        self.report_stage_metrics(metrics)
+        self.update_progress(1.0)
+        self.logger.info(f"Tracking finished: {totals}")
diff --git a/ami/ml/schemas.py b/ami/ml/schemas.py
index 9322e4116..36bcc0afa 100644
--- a/ami/ml/schemas.py
+++ b/ami/ml/schemas.py
@@ -133,6 +133,22 @@ class ClassificationResponse(pydantic.BaseModel):
     )
     scores: list[float] = []
     logits: list[float] | None = None
+    features: list[float] | None = pydantic.Field(
+        default=None,
+        description=(
+            "Optional feature embedding vector from the model backbone, used for tracking and similarity search. "
+            "Only 2048-float vectors are stored; a vector of another length is dropped with a warning."
+        ),
+    )
+
+    @pydantic.validator("features")
+    def _features_length(cls, v):
+        # Dropped rather than rejected, so one model's vector size never fails the batch it came in.
+        if v is not None and len(v) != 2048:
+            logger.warning(f"Dropping a feature vector of length {len(v)}; only 2048-float vectors are stored.")
+            return None
+        return v
+
     inference_time: float | None = None
     algorithm: AlgorithmReference
     terminal: bool = True
@@ -178,23 +194,45 @@ class DetectionResponse(pydantic.BaseModel):
     classifications: list[ClassificationResponse] = []
 
 
-class PipelineRequestConfigParameters(dict):
+class PipelineRequestConfigParameters(pydantic.BaseModel):
     """Parameters used to configure a pipeline request.
 
-    Accepts any serializable key-value pair.
+    The declared fields carry Antenna's defaults for every request; any other
+    serializable key-value pair is accepted and forwarded as-is, so a pipeline
+    or project config can pass service-specific options without a schema change.
     Example: {"force_reprocess": True, "auth_token": "abc123"}
 
     Supported parameters are defined by the pipeline in the processing service
     and should be published in the Pipeline's info response.
 
     Parameters that are used by Antenna before sending the request to the Processing Service
-    should be prefixed with "request_".
-    Example: {"request_source_image_batch_size": 8}
-    Such parameters need to be ignored by the schema in the Processing Service, or
-    removed before sending the request to the Processing Service.
+    are prefixed with "request_". The processing service ignores them.
     """
 
-    pass
+    include_features: bool = pydantic.Field(
+        default=True,
+        description=(
+            "Ask the processing service for a feature vector with each classification. "
+            "Tracking and the merge picker compare detections by these vectors; a service "
+            "that cannot produce them ignores the flag."
+        ),
+    )
+    request_source_image_batch_size: int = pydantic.Field(
+        default=1,
+        ge=1,
+        description="How many source images Antenna sends to the processing service per request.",
+    )
+    reprocess_existing_detections: bool = pydantic.Field(
+        default=True,
+        description=(
+            "Send the existing detections of each image along with the request so the service "
+            "classifies them again instead of detecting anew. Only applies when the project's "
+            "feature flag of the same name is on."
+        ),
+    )
+
+    class Config:
+        extra = "allow"
 
 
 class PipelineRequest(pydantic.BaseModel):
diff --git a/ami/ml/tests.py b/ami/ml/tests.py
index bd92bb02f..cd49dea61 100644
--- a/ami/ml/tests.py
+++ b/ami/ml/tests.py
@@ -873,9 +873,10 @@ def test_project_pipeline_config(self):
         from ami.ml.models import ProjectPipelineConfig
         from ami.ml.schemas import PipelineRequestConfigParameters
 
-        # Add config to the pipeline & project
-        self.pipeline.default_config = PipelineRequestConfigParameters({"test_param": "test_value"})
+        # Add config to the pipeline & project. Keys the schema does not declare are kept.
+        self.pipeline.default_config = PipelineRequestConfigParameters(test_param="test_value")
         self.pipeline.save()
+        self.pipeline.refresh_from_db()
         self.project_pipeline_config = ProjectPipelineConfig.objects.create(
             project=self.project,
             pipeline=self.pipeline,
@@ -885,9 +886,60 @@ def test_project_pipeline_config(self):
 
         # Check the final config
         default_config = self.pipeline.get_config()
-        self.assertEqual(default_config["test_param"], "test_value")
+        self.assertEqual(default_config.dict()["test_param"], "test_value")
         final_config = self.pipeline.get_config(self.project.pk)
-        self.assertEqual(final_config["test_param"], "project_value")
+        self.assertEqual(final_config.dict()["test_param"], "project_value")
+
+        # The project's overrides stay out of the pipeline default and out of the next call.
+        self.assertNotIn("project_value", self.pipeline.default_config.dict().values())
+        self.assertEqual(self.pipeline.get_config().dict()["test_param"], "test_value")
+
+    def test_feature_vectors_are_requested_unless_a_config_opts_out(self):
+        """Every request asks the service for classification feature vectors, since tracking and
+        the merge picker compare detections by them; a project config can still turn them off."""
+        from ami.ml.models import Pipeline, ProjectPipelineConfig
+
+        self.assertIs(self.pipeline.get_config().include_features, True)
+        self.assertIs(self.pipeline.get_config(self.project.pk).include_features, True)
+        # A pipeline that was never given a config, saved or not, still asks for them.
+        self.assertIs(Pipeline(name="bare", slug="bare").get_config().include_features, True)
+        self.assertIs(Pipeline.objects.create(name="stored", slug="stored").get_config().include_features, True)
+
+        ProjectPipelineConfig.objects.create(
+            project=self.project, pipeline=self.pipeline, config={"include_features": False}
+        )
+        self.assertIs(self.pipeline.get_config(self.project.pk).include_features, False)
+        self.assertIs(self.pipeline.get_config().include_features, True)
+
+    def test_request_batch_size_comes_from_the_config_with_a_floor_of_one(self):
+        """The job splits its images by the configured batch size; the schema default is one image
+        per request and a size below one is rejected instead of producing empty batches."""
+        import pydantic
+
+        from ami.ml.models import ProjectPipelineConfig
+
+        self.assertEqual(self.pipeline.get_config().request_source_image_batch_size, 1)
+        project_config = ProjectPipelineConfig.objects.create(
+            project=self.project, pipeline=self.pipeline, config={"request_source_image_batch_size": 8}
+        )
+        self.assertEqual(self.pipeline.get_config(self.project.pk).request_source_image_batch_size, 8)
+
+        # The project config is a plain JSON field, so the check happens when the request config is built.
+        project_config.config = {"request_source_image_batch_size": 0}
+        project_config.save()
+        with self.assertRaises(pydantic.ValidationError):
+            self.pipeline.get_config(self.project.pk)
+
+    def test_request_config_is_sent_to_the_service_with_extra_keys(self):
+        """The processing service receives the resolved config, defaults and pass-through keys alike,
+        under the request's config key."""
+        from ami.ml.schemas import PipelineRequest
+
+        self.pipeline.default_config = {"auth_token": "abc123"}
+        request = PipelineRequest(pipeline=self.pipeline.slug, source_images=[], config=self.pipeline.get_config())
+        sent = request.dict()["config"]
+        self.assertEqual(sent["include_features"], True)
+        self.assertEqual(sent["auth_token"], "abc123")
 
     def test_image_with_null_detection(self):
         """
@@ -2288,3 +2340,28 @@ def test_used_lookup_is_deduplicated_in_the_database(self):
             len(list(lookup.order_by().distinct())), 1, "Deduplicating collapses them to the one algorithm"
         )
         self.assertIn("Chatty Masked Classifier", self._choice_names(self.project.pk))
+
+
+class TestClassificationFeaturesLength(unittest.TestCase):
+    """A feature vector of an unexpected length is dropped with a warning, so one model's
+    vector size never fails the whole batch of results it arrived with."""
+
+    def _response(self, features: list[float] | None):
+        from ami.ml.schemas import AlgorithmReference, ClassificationResponse
+
+        return ClassificationResponse(
+            classification="Moth",
+            scores=[1.0],
+            features=features,
+            algorithm=AlgorithmReference(name="Classifier", key="classifier"),
+            timestamp=datetime.datetime(2026, 1, 1),
+        )
+
+    def test_a_2048_float_vector_is_kept(self):
+        self.assertEqual(len(self._response([0.5] * 2048).features or []), 2048)
+
+    def test_a_vector_of_another_length_is_dropped_with_a_warning(self):
+        with self.assertLogs("ami.ml.schemas", level="WARNING") as logs:
+            response = self._response([0.5] * 1024)
+        self.assertIsNone(response.features)
+        self.assertIn("1024", logs.output[0])
diff --git a/ami/templates/admin/post_processing/confirmation.html b/ami/templates/admin/post_processing/confirmation.html
index 565f3f2e0..d4c9414c4 100644
--- a/ami/templates/admin/post_processing/confirmation.html
+++ b/ami/templates/admin/post_processing/confirmation.html
@@ -15,6 +15,11 @@
 {% block content %}
   <form method="post">
     {% csrf_token %}
+    {% if form.notice %}
+      <ul class="messagelist">
+        <li class="warning">{{ form.notice }}</li>
+      </ul>
+    {% endif %}
     {% block intro %}
       <p>
         You are about to run <strong>{{ task_label }}</strong> on
diff --git a/ami/tests/fixtures/images.py b/ami/tests/fixtures/images.py
index 3a1984516..45d210ac4 100644
--- a/ami/tests/fixtures/images.py
+++ b/ami/tests/fixtures/images.py
@@ -136,6 +136,8 @@ class GeneratedTestFrame:
     filename: str
     bounding_boxes: list[BoundingBoxWithIdentifier]
     object_store_key: str | None = None
+    # Position of this frame in its series, counting from zero.
+    frame_num: int = 0
 
 
 def generate_moth_series(
@@ -148,12 +150,29 @@ def generate_moth_series(
     minutes_interval_variation: int = 10,
     save_images: bool = True,
     output_dir: str = "generated_test_captures",
+    motion_scale: float | None = None,
+    moth_size_range: tuple[int, int] = (30, 60),
+    min_frames_per_moth: int | None = None,
+    num_transient_moths: int = 0,
 ) -> list[GeneratedTestFrame]:
+    """
+    Draw a series of frames in which the same simulated moths move a little between captures.
+
+    ``motion_scale`` sets how far a moth travels and turns between two frames. Left unset it
+    grows with ``minutes_interval``, which suits captures far enough apart that nothing is
+    expected to stay in place. Occurrence tracking matches on bounding-box overlap, so data
+    meant for tracking wants a small scale (well under 1) and closely-spaced captures.
+
+    ``min_frames_per_moth`` staggers arrivals and departures so each moth is visible for a
+    contiguous run of at least that many frames instead of the whole series.
+    ``num_transient_moths`` adds moths that show up in exactly one frame.
+    """
     background = create_background(width, height)
     moths = []
     image_data = []
 
     num_moths = num_moths or random.randint(2, 8)
+    total_moths = num_moths + num_transient_moths
 
     # pick random day, start at 10pm in the last 10 years
     if beginning_timestamp is None:
@@ -166,18 +185,39 @@ def generate_moth_series(
 
     # Generate unique identifiers
     # identifiers = ["".join(random.choices(string.ascii_uppercase + string.digits, k=2)) for _ in range(num_moths)]
-    # The font is very hard to read, so replace with a simple number repeated 3 times
-    identifiers = [f"{i}{i}{i}" for i in range(num_moths)]
-
-    # Initialize moths
-    for i in range(num_moths):
-        size = random.randint(30, 60)
+    # The font is very hard to read, so replace with a simple number repeated 3 times.
+    # Past the tenth moth there is no single digit left to repeat, so fall back to a
+    # zero-padded number, which is still three characters wide.
+    identifiers = [f"{i}{i}{i}" if i < 10 else f"{i:03d}" for i in range(total_moths)]
+
+    # Initialize moths. A moth is drawn in frames first_frame..last_frame inclusive;
+    # the ones added after the first num_moths appear in a single frame each.
+    for i in range(total_moths):
+        transient = i >= num_moths
+        size = random.randint(*moth_size_range)
         x = random.randint(size // 2, width - size // 2)
         y = random.randint(size // 2, height - size // 2)
         color = random_base_color()
         rotation = random.uniform(0, 360)
+        if transient:
+            first_frame = last_frame = random.randint(0, num_frames - 1)
+        elif min_frames_per_moth is None:
+            first_frame, last_frame = 0, num_frames - 1
+        else:
+            span = random.randint(min(min_frames_per_moth, num_frames), num_frames)
+            first_frame = random.randint(0, num_frames - span)
+            last_frame = first_frame + span - 1
         moths.append(
-            {"identifier": identifiers[i], "size": size, "x": x, "y": y, "color": color, "rotation": rotation}
+            {
+                "identifier": identifiers[i],
+                "size": size,
+                "x": x,
+                "y": y,
+                "color": color,
+                "rotation": rotation,
+                "first_frame": first_frame,
+                "last_frame": last_frame,
+            }
         )
 
     for frame in range(num_frames):
@@ -189,9 +229,12 @@ def generate_moth_series(
         bounding_boxes = []
 
         for moth in moths:
+            if not moth["first_frame"] <= frame <= moth["last_frame"]:
+                continue
+
             # Update position and rotation
             # Add multiply factor based on interval minutes to make movement more noticeable. min is 1, max is 120.
-            mult_factor = max(minutes_interval / 120, 1) + 2
+            mult_factor = motion_scale if motion_scale is not None else max(minutes_interval / 120, 1) + 2
             # moth["x"] += random.randint(-10, 10)
             # moth["y"] += random.randint(-10, 10)
             # moth["rotation"] += random.uniform(-15, 15)
@@ -226,6 +269,7 @@ def generate_moth_series(
             filename=image_filename,
             bounding_boxes=bounding_boxes,
             image=image,
+            frame_num=frame,
         )
 
         if save_images:
diff --git a/ami/tests/fixtures/main.py b/ami/tests/fixtures/main.py
index 073f00099..8953712b2 100644
--- a/ami/tests/fixtures/main.py
+++ b/ami/tests/fixtures/main.py
@@ -24,6 +24,7 @@
 from ami.ml.models.processing_service import ProcessingService
 from ami.ml.tasks import create_detection_images
 from ami.tests.fixtures.storage import GeneratedTestFrame, create_storage_source, populate_bucket
+from ami.tests.fixtures.tracking import create_tracking_session
 from ami.users.models import User
 
 logger = logging.getLogger(__name__)
@@ -206,14 +207,21 @@ def create_captures_from_files(
 def create_taxa(project: Project) -> TaxaList:
     taxa_list = TaxaList.objects.create(name="Test Taxa List")
     taxa_list.projects.add(project)
-    root, _created = Taxon.objects.get_or_create(name="Lepidoptera", rank=TaxonRank.ORDER.name)
+    # Taxon names are unique across the whole database, so match on the name alone and let
+    # the rank and parent apply only to a taxon this fixture creates. Matching on the parent
+    # as well fails outright against a database that already holds these names.
+    root, _created = Taxon.objects.get_or_create(name="Lepidoptera", defaults=dict(rank=TaxonRank.ORDER.name))
     root.projects.add(project)
-    family_taxon, _ = Taxon.objects.get_or_create(name="Nymphalidae", parent=root, rank=TaxonRank.FAMILY.name)
+    family_taxon, _ = Taxon.objects.get_or_create(
+        name="Nymphalidae", defaults=dict(parent=root, rank=TaxonRank.FAMILY.name)
+    )
     family_taxon.projects.add(project)
-    genus_taxon, _ = Taxon.objects.get_or_create(name="Vanessa", parent=family_taxon, rank=TaxonRank.GENUS.name)
+    genus_taxon, _ = Taxon.objects.get_or_create(
+        name="Vanessa", defaults=dict(parent=family_taxon, rank=TaxonRank.GENUS.name)
+    )
     genus_taxon.projects.add(project)
+    species_taxa = []
     for species in ["Vanessa itea", "Vanessa cardui", "Vanessa atalanta"]:
-        species_taxa = []
         taxon, _ = Taxon.objects.get_or_create(
             name=species,
             defaults=dict(
@@ -315,7 +323,12 @@ def make_identifier(series_id: str, bbox_identifier: str):
             identifier = make_identifier(frame.series_id, bbox.identifier)
             detections_by_identifier.setdefault(identifier, []).append((source_image, bbox.bbox))
 
-    algorithm = Algorithm.objects.get(key="random-species-classifier")
+    # The processing service registers this algorithm when it is reachable. Fall back to a
+    # placeholder with the same key so the demo project can be built with no backend running.
+    algorithm, _ = Algorithm.objects.get_or_create(
+        key="random-species-classifier",
+        defaults=dict(name="Random Species Classifier", task_type="classification"),
+    )
 
     for identifier, detections in detections_by_identifier.items():
         assert source_image.deployment
@@ -405,13 +418,28 @@ def create_occurrences(
         assert occurrence.determination_score is not None
 
 
-def create_complete_test_project():
+def create_complete_test_project(with_tracking_session: bool = False, **tracking_kwargs):
+    """
+    Build a project with a couple of nights of captures, detections and occurrences.
+
+    Returns the project and, when ``with_tracking_session`` is set, the ground truth of a
+    further night shaped for occurrence tracking. That night is off by default because this
+    function also runs from the ``post_migrate`` signal that seeds an empty database, and it
+    costs another two dozen generated images.
+    """
     with transaction.atomic():
         project, deployment = setup_test_project(reuse=False)
         frame_data = create_captures_from_files(deployment)
         taxa_list = create_taxa(project)
         create_occurrences_from_frame_data(frame_data, taxa_list=taxa_list)
+        ground_truth = None
+        if with_tracking_session:
+            ground_truth = create_tracking_session(deployment, taxa_list=taxa_list, **tracking_kwargs)
+            # Track editing is opt-in per project; a demo built for tracking opts in.
+            project.feature_flags.tracking = True
+            project.save(update_fields=["feature_flags"])
         logger.info(f"Created test project {project}")
+        return project, ground_truth
 
 
 def create_local_admin_user():
diff --git a/ami/tests/fixtures/tracking.py b/ami/tests/fixtures/tracking.py
new file mode 100644
index 000000000..01944225d
--- /dev/null
+++ b/ami/tests/fixtures/tracking.py
@@ -0,0 +1,306 @@
+"""A synthetic capture session that occurrence tracking can actually group.
+
+Tracking links detections in *consecutive* captures, so data that scatters detections
+across non-adjacent captures produces no links at all. What this module generates is one
+long run of closely-spaced captures in which each simulated insect holds still enough for
+its bounding boxes to overlap frame to frame, alongside the ground-truth grouping a
+tracking run can be scored against.
+
+The session is left the way a real pipeline leaves a session: one occurrence per
+detection, no ``next_detection`` links. That is what ``event_is_fresh()`` expects.
+"""
+
+import dataclasses
+import datetime
+import io
+import logging
+import pathlib
+import random
+
+import numpy as np
+from django.db import connection, models
+
+from ami.main.models import (
+    Classification,
+    Deployment,
+    Detection,
+    Event,
+    Occurrence,
+    SourceImage,
+    SourceImageCollection,
+    TaxaList,
+    Taxon,
+    TaxonRank,
+    group_images_into_events,
+)
+from ami.ml.models.algorithm import Algorithm
+from ami.ml.tasks import create_detection_images
+from ami.tests.fixtures.images import generate_moth_series
+from ami.utils import s3
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SEED = 20260902
+
+# One algorithm stands in for the classifier that would have produced both the species
+# label and the backbone embedding. Tracking infers its feature extractor from the
+# classifications on an event, and refuses to guess when more than one produced features.
+DEMO_CLASSIFIER_KEY = "demo-tracking-classifier"
+DEMO_CLASSIFIER_NAME = "Demo Tracking Classifier"
+
+# Measured at these defaults: an insect's own consecutive detections score under 0.15 on the
+# geometry-only matching cost, and two different insects never score below 1.2. Raise the
+# scale to make the session harder to track; larger moths tolerate drift better.
+DEFAULT_MOTION_SCALE = 0.2
+TRACKING_MOTH_SIZE_RANGE = (50, 90)
+
+
+@dataclasses.dataclass
+class SimulatedInsect:
+    """One simulated insect: the detections a perfect tracking run would group together."""
+
+    identifier: str
+    taxon_name: str
+    frame_numbers: list[int]
+    detection_ids: list[int]
+
+
+@dataclasses.dataclass
+class TrackingSessionGroundTruth:
+    """Everything needed to score a tracking run over the generated session."""
+
+    project_id: int
+    deployment_id: int
+    event_id: int
+    capture_set_id: int
+    seed: int
+    capture_count: int
+    detection_count: int
+    feature_algorithm_key: str | None
+    insects: list[SimulatedInsect]
+
+    @property
+    def chain_lengths(self) -> list[int]:
+        return sorted((len(insect.detection_ids) for insect in self.insects), reverse=True)
+
+    def as_dict(self) -> dict:
+        return dataclasses.asdict(self)
+
+
+def pgvector_is_available() -> bool:
+    """Can this database store ``Classification.features_2048``?"""
+    with connection.cursor() as cursor:
+        cursor.execute("SELECT 1 FROM pg_extension WHERE extname = 'vector'")
+        return cursor.fetchone() is not None
+
+
+def _session_start_timestamp(deployment: Deployment) -> datetime.datetime:
+    """Pick a night of its own for the tracking session.
+
+    Captures group into events by time, so starting a week before anything else in the
+    deployment keeps the session in an event nobody else shares. Naive local time,
+    because ``USE_TZ`` is off and capture timestamps are deployment-local.
+    """
+    earliest = SourceImage.objects.filter(deployment=deployment).aggregate(models.Min("timestamp"))["timestamp__min"]
+    if earliest:
+        return earliest - datetime.timedelta(days=7)
+    return (datetime.datetime.now() - datetime.timedelta(days=1)).replace(hour=21, minute=0, second=0, microsecond=0)
+
+
+def _species_taxa(project, taxa_list: TaxaList | None) -> list[Taxon]:
+    taxa_qs = taxa_list.taxa if taxa_list else Taxon.objects.filter(projects=project)
+    species = list(taxa_qs.filter(rank=TaxonRank.SPECIES.name).order_by("name"))
+    if not species:
+        raise ValueError("No species-rank taxa available to classify the simulated insects with.")
+    return species
+
+
+def _upload_frames(deployment: Deployment, frames) -> None:
+    if deployment.data_source is None:
+        raise ValueError(f"Deployment {deployment.pk} has no data source to upload generated captures to.")
+    config = deployment.data_source.config
+    subdir = f"deployment_{deployment.pk}"
+    for frame in frames:
+        buffer = io.BytesIO()
+        frame.image.save(buffer, format="JPEG")
+        key = f"{subdir}/{frame.filename}"
+        s3.write_file(config, key, buffer.getvalue())
+        frame.object_store_key = key
+    logger.info(f"Uploaded {len(frames)} tracking frames to {config.bucket_name}/{subdir}")
+
+
+def _captures_for_frames(deployment: Deployment, frames) -> list[SourceImage]:
+    """Return the imported captures for ``frames``, in frame order."""
+    filenames = [frame.filename for frame in frames]
+    by_filename = {
+        pathlib.Path(image.path).name: image
+        for image in SourceImage.objects.filter(deployment=deployment)
+        if image.path
+    }
+    missing = [name for name in filenames if name not in by_filename]
+    if missing:
+        raise RuntimeError(f"{len(missing)} generated frame(s) were not imported by sync_captures: {missing[:3]}")
+    return [by_filename[name] for name in filenames]
+
+
+def create_tracking_session(
+    deployment: Deployment,
+    taxa_list: TaxaList | None = None,
+    num_frames: int = 24,
+    minutes_interval: int = 2,
+    num_moths: int = 6,
+    num_transient_moths: int = 4,
+    min_frames_per_moth: int = 6,
+    motion_scale: float = DEFAULT_MOTION_SCALE,
+    with_features: bool = True,
+    create_crops: bool = True,
+    seed: int = DEFAULT_SEED,
+) -> TrackingSessionGroundTruth:
+    """
+    Add one trackable capture session to ``deployment`` and return its ground truth.
+
+    ``num_moths`` insects each stay for a run of at least ``min_frames_per_moth`` captures,
+    which is what gives tracking real chains to rebuild; ``num_transient_moths`` appear in a
+    single frame each, which is what gives it singletons it must leave alone.
+
+    The same ``seed`` reproduces the same positions, lifespans, species and scores; it is set
+    on the global ``random`` module, so it also affects whatever runs next in the process. It
+    does not reproduce the same primary keys, which is why the returned ground truth, not the
+    seed, is the record to score a run against.
+    """
+    random.seed(seed)
+    rng = np.random.default_rng(seed)
+
+    frames = generate_moth_series(
+        num_frames=num_frames,
+        num_moths=num_moths,
+        num_transient_moths=num_transient_moths,
+        min_frames_per_moth=min_frames_per_moth,
+        beginning_timestamp=_session_start_timestamp(deployment),
+        minutes_interval=minutes_interval,
+        minutes_interval_variation=0,
+        motion_scale=motion_scale,
+        moth_size_range=TRACKING_MOTH_SIZE_RANGE,
+        save_images=False,
+    )
+    _upload_frames(deployment, frames)
+
+    # Group only after the dimensions are in place: grouping otherwise reads the first
+    # image back out of object storage to fill them in, and the matching cost needs them.
+    deployment.sync_captures(regroup_after=False)
+    captures = _captures_for_frames(deployment, frames)
+    SourceImage.objects.filter(pk__in=[c.pk for c in captures]).update(width=frames[0].width, height=frames[0].height)
+    group_images_into_events(deployment)
+    captures = _captures_for_frames(deployment, frames)
+
+    algorithm, _ = Algorithm.objects.get_or_create(
+        key=DEMO_CLASSIFIER_KEY, defaults=dict(name=DEMO_CLASSIFIER_NAME, task_type="classification")
+    )
+    store_features = with_features and pgvector_is_available()
+    if with_features and not store_features:
+        logger.warning(
+            "The pgvector extension is not installed, so no feature embeddings will be generated. "
+            "Track this session with require_features=False."
+        )
+
+    species = _species_taxa(deployment.project, taxa_list)
+    identifiers = sorted({box.identifier for frame in frames for box in frame.bounding_boxes})
+    taxon_by_insect = {identifier: species[i % len(species)] for i, identifier in enumerate(identifiers)}
+    base_vector_by_insect = {identifier: rng.random(2048) for identifier in identifiers}
+
+    insects = {
+        identifier: SimulatedInsect(
+            identifier=identifier,
+            taxon_name=taxon_by_insect[identifier].name,
+            frame_numbers=[],
+            detection_ids=[],
+        )
+        for identifier in identifiers
+    }
+
+    for capture, frame in zip(captures, frames):
+        for box in frame.bounding_boxes:
+            occurrence = Occurrence.objects.create(
+                event=capture.event,
+                deployment=capture.deployment,
+                project=capture.project,
+            )
+            detection = Detection.objects.create(
+                source_image=capture,
+                occurrence=occurrence,
+                timestamp=capture.timestamp,
+                bbox=list(box.bbox),
+                frame_num=frame.frame_num,
+            )
+            features = None
+            if store_features:
+                features = (base_vector_by_insect[box.identifier] + rng.normal(0, 0.001, size=2048)).tolist()
+            Classification.objects.create(
+                detection=detection,
+                taxon=taxon_by_insect[box.identifier],
+                algorithm=algorithm,
+                score=random.randint(65, 98) / 100,
+                timestamp=capture.timestamp,
+                terminal=True,
+                features_2048=features,
+            )
+            occurrence.save()
+            insects[box.identifier].frame_numbers.append(frame.frame_num)
+            insects[box.identifier].detection_ids.append(detection.pk)
+        capture.save()
+
+    event = captures[0].event
+    if event is None:
+        raise RuntimeError("The generated captures were not grouped into an event.")
+    capture_set = SourceImageCollection.objects.create(
+        project=deployment.project,
+        name=f"Tracking Demo Session {event.pk}",
+        description="One night of closely-spaced captures with a known occurrence grouping.",
+    )
+    capture_set.images.set(captures)
+
+    if create_crops:
+        # Cropping fetches every capture back out of object storage, which is the slow part
+        # of this fixture. Tests that only care about the grouping can skip it.
+        create_detection_images(source_image_ids=[capture.pk for capture in captures])
+
+    detection_count = sum(len(insect.detection_ids) for insect in insects.values())
+    logger.info(
+        f"Created tracking session: event {event.pk}, {len(captures)} captures, "
+        f"{detection_count} detections, {len(insects)} simulated insects."
+    )
+
+    return TrackingSessionGroundTruth(
+        project_id=deployment.project.pk,
+        deployment_id=deployment.pk,
+        event_id=event.pk,
+        capture_set_id=capture_set.pk,
+        seed=seed,
+        capture_count=len(captures),
+        detection_count=detection_count,
+        feature_algorithm_key=algorithm.key if store_features else None,
+        insects=[insects[identifier] for identifier in identifiers],
+    )
+
+
+def score_tracking_run(ground_truth: TrackingSessionGroundTruth) -> dict:
+    """Compare the occurrences currently in the database against the ground truth.
+
+    Returns the counts a tracking run should be judged on: how many simulated insects were
+    rebuilt exactly, how many occurrences the event now holds, and the longest chain found.
+    """
+    event = Event.objects.get(pk=ground_truth.event_id)
+    groups = [
+        set(occurrence.detections.values_list("pk", flat=True))
+        for occurrence in Occurrence.objects.filter(event=event)
+    ]
+    groups = [group for group in groups if group]
+    truth = [set(insect.detection_ids) for insect in ground_truth.insects]
+    exact = sum(1 for group in truth if group in groups)
+    return {
+        "simulated_insects": len(truth),
+        "occurrences": len(groups),
+        "exactly_recovered": exact,
+        "longest_chain": max((len(group) for group in groups), default=0),
+        "longest_true_chain": max((len(group) for group in truth), default=0),
+    }
diff --git a/ami/users/roles.py b/ami/users/roles.py
index 718146e41..f32274619 100644
--- a/ami/users/roles.py
+++ b/ami/users/roles.py
@@ -146,6 +146,9 @@ class MLDataManager(Role):
         Project.Permissions.SYNC_DEPLOYMENT,
         Project.Permissions.RUN_REGROUP_EVENTS_JOB,
         Project.Permissions.RUN_DATA_EXPORT_JOB,
+        # Runs post-processing jobs that a member may create (tracking only, on projects
+        # that opted in); staff tasks stay superuser-only in Job.check_custom_permission.
+        Project.Permissions.RUN_POST_PROCESSING_JOB,
         Project.Permissions.DELETE_OCCURRENCES,
         Project.Permissions.CREATE_PROJECT_PIPELINE_CONFIG,
         Project.Permissions.UPDATE_PROJECT_PIPELINE_CONFIG,
diff --git a/compose/local/postgres/Dockerfile b/compose/local/postgres/Dockerfile
index 5f864a4a0..9192b8808 100644
--- a/compose/local/postgres/Dockerfile
+++ b/compose/local/postgres/Dockerfile
@@ -1,6 +1,13 @@
 FROM postgres:16
 # FROM esgn/pgtuned:latest
 
+# pgvector for Classification.features_2048 (migration 0096). Pinned to the 0.8 series so
+# every environment starts on the same current release.
+ARG PGVECTOR_VERSION=0.8.*
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends "postgresql-16-pgvector=${PGVECTOR_VERSION}" \
+    && rm -rf /var/lib/apt/lists/*
+
 COPY ./compose/local/postgres/maintenance /usr/local/bin/maintenance
 RUN chmod +x /usr/local/bin/maintenance/*
 RUN mv /usr/local/bin/maintenance/* /usr/local/bin \
diff --git a/docs/claude/INDEX.md b/docs/claude/INDEX.md
index 61f0980d8..b606cc2b1 100644
--- a/docs/claude/INDEX.md
+++ b/docs/claude/INDEX.md
@@ -17,6 +17,9 @@ archived.
 | `reference/react-form-to-drf-values.md` | How form values travel from React Hook Form through the API into DRF serializers (empty string vs null vs undefined). Keywords: forms, serializers, frontend |
 | `reference/captures-processed-count-strategies.md` | COUNT strategies for the captures `processed`/`has_detections` annotations (PR #1326). Keywords: captures, counts, performance |
 | `reference/hierarchical-rollup-query-performance.md` | Per-taxon rollup counts on `GET /api/v2/taxa/` — query patterns and pitfalls. Keywords: taxa, rollup, counts |
+| `reference/occurrence-tracking.md` | How occurrences are populated by tracking: data model (`next_detection`, `features_2048`), cost function, config knobs, the adjacent-processed-captures constraint, how to run it, where results show up, all six editing endpoints (split/remove/merge/add/verify/unverify), the chain-boundary and clear-on-edit invariants, permission traps, and how to generate a demo session with known ground truth (`create_demo_project`). Keywords: tracking, occurrences, pgvector, embeddings, abundance, grouping verification, test set, demo data |
+| `reference/tracking-evaluation.md` | Scoring tracking against human-confirmed tracks (`grouping_verified_at`): metrics over detections in confirmed tracks only (pairwise and link precision/recall, fragments, completeness, purity, merges), the `evaluate_tracking` command (re-links raw detections read-only via `propose_event_links`, rolled back), the no-Django CSV mode, limits and next steps. Keywords: tracking evaluation, benchmark, ground truth, confirmed tracks, metrics |
+| `planning/idempotent-incremental-tracking.md` | Design for tracking that is always safe to re-run: the unit of work becomes a pair of adjacent processed captures rather than a whole session, with the successor marker recorded on `SourceImage`. Covers moving adjacency, bookkeeping without a new table, identification migration on merge, surviving human edits, concurrency, cost, and the trigger. Keywords: idempotent, incremental, tracking, adjacency, re-run, sampled captures |
 
 ## Architecture notes
 
diff --git a/docs/claude/planning/2026-09-13-tracking-feedback-plan.md b/docs/claude/planning/2026-09-13-tracking-feedback-plan.md
new file mode 100644
index 000000000..850494fe8
--- /dev/null
+++ b/docs/claude/planning/2026-09-13-tracking-feedback-plan.md
@@ -0,0 +1,101 @@
+# Occurrence tracking: work plan from the first partner review (2026-09-13)
+
+Source: a partner reviewed the tracking branch (PR #1272 head 2560b4f9) on a dev deployment with three benchmark
+sessions and wrote up seven hands-on tests, plus our own notes from the demo. Verbatim feedback and screenshots are in
+the session notes under `docs/claude/sessions/` dated 2026-09-13 (kept out of the public repo).
+Meta ticket: #1412. Numbers in brackets refer to the feedback table in the session doc.
+
+Headline from the review: the tracker is conservative (1 wrong link in 77 hand-checked tracks of one species) and the
+edit tools work, but reviewers cannot finish tracks because frames rejected by the moth/non-moth filter or hidden by
+project filters never appear as merge candidates, and building a track by hand needs too many clicks.
+
+## Work packages
+
+| Pkg | Title (issue title, effect first) | Items | Effort | Depends on | Files |
+|---|---|---|---|---|---|
+| A | Rank merge candidates by time adjacency, show the frames next to a track first, and merge several at once (#1414) | 4, 1, 2, 5, 22, 23 | S–M | – | `models_future/merge_candidates.py`, `OccurrenceViewSet.merge_candidates`/`merge`, merge dialog FE, `useTrackCandidates.ts` (move dialog uses an unranked hook) |
+| B | Make reviewing a track faster: close on confirm, crop grid, names per frame, edited vs verified state (#1415) | 11, 8, 3, 6 | S–M | – | occurrence detail FE, `track_stats.grouping_summary`, model field `grouping_edited_at/by` + migration |
+| C | Extend a track by clicking detections in the session view (#1418) | 7, 13 | M | A (comparison crop component) | session detail FE (`extend=` URL param), `POST /occurrences/{id}/add-detections/` (exists) |
+| D | Preview a tracking run without writing (dry run) (#1416) | 14 | S | – | `tracking_task.py` (per-event atomic block already exists), job params |
+| E | Bridge one-frame gaps, weight the cost terms, and use label agreement when linking | 9, 10, 12, 22 | M | D (measure before/after) | `tracking_task.pair_detections`, store per-link cost/similarity on `Detection` |
+| F | Tracking playground: tune parameters live on a dozen captures | 21 | BE S–M, FE M | E (shared cost function) | new endpoint returning per-pair cost components; new page |
+| G | Feature vectors for every detection, not only moths (#1417 + RolnickLab/ami-data-companion#170) | 4b, 18 | M (embedding output in the service schema + `DetectionEmbedding` table; the cheap "reuse the species classifier" path is ruled out, see measurements) | – | ami-data-companion pipeline, `ami/ml/schemas.py`, new model |
+| H | Restrict a project's species to a regional list | 19 | S (deploy) | class masking PR #999 | deploy + TaxaList CSV import |
+| I | Re-tracking a session after hand edits | fresh-guard finding | M | – | `event_is_fresh`, chain walk must respect `grouping_verified_at` |
+| J | Max M per species per session (max in one frame vs individuals per night) | 15 | S–M | – | session stats annotation + export column |
+
+Ticketed on 2026-09-13 as sub-issues of #1412 (A, B, C, D, G, and the processing-service counterpart of G). The data
+checklist (keep the reviewed project unchanged, copy and reprocess with vectors for every detection, ask for regional
+species checklists) is a comment on #1412. E, F, H, I and J stay in this plan until the annotation set exists.
+
+Parked: movement prior per species (16), detector issues (17) belong to the processing service.
+
+## Findings from the screenshots (added 2026-09-13, after reading all 33 images)
+
+- The candidate picker shows the API order (tracker cost ascending). In one review case a 14-frame track of the same
+  species, 3 % of the diagonal away and 99 % similar, ranked last of six: a small displacement zeroes the IoU term,
+  which alone outweighs the appearance term. Package E should weight the terms; package A can default-sort by
+  similarity when it is present.
+- The "Move to another occurrence" dialog lists species and frame count only. It reads nearby occurrences through an
+  unranked hook rather than the ranked endpoint, so it needs a `detection=` variant of that endpoint.
+- Every frame the reviewer could not attach carried the moth/non-moth filter's "not a moth" label and no embedding
+  (similarity shown as n/a). Package A removes the filter block; package G gives those frames a vector.
+- The occurrence list shows no capture id or time, so a reviewer cannot tell from the list whether five single-frame
+  occurrences of a distinctive species are consecutive captures (package C, list part).
+
+## Measurements on the dev deployment (2026-09-13)
+
+- **Why reviewers saw one or two usable candidates.** With the default ±5 minute window, a track in the dense
+  session has 1,600–1,800 candidate occurrences and the endpoint returns the 50 lowest-cost. Those are almost all
+  *overlapping* occurrences (other moths present at the same time, nearest-frame cost ≈1.1). The frame that actually
+  continues the track ranked 4th, 35th, or not at all in the three dense tracks probed; in the quiet session (22–46
+  candidates) everything fits and the true neighbour ranks first or second. Vector-less frames are not excluded:
+  12–16 of ~500 made the top 50 in the dense session, all of them in the quiet one. Project default filters played
+  no part: the dev project has threshold 0 and no taxa filters.
+- **Vector-less detections are all the moth/non-moth filter's rejects:** 2,314 of 8,259 (dense), 264 of 782
+  (quiet), 627 of 3,127 (mixed). The quiet session's occurrences are 131 of 154 "not a moth" singletons, the mixed
+  one 485 of 1,855, so a fully annotated set has to bulk-handle those.
+- **The dev project is now an annotation set** (127 identifications and 17 verified groupings by the partner since
+  the demo) and must be frozen: no re-tracking in place; algorithm changes run on a copy or as a dry run (package D).
+- **The cheap path to vectors is ruled out.** Running the species classifier on the rejected crops would add species
+  classifications and change those occurrences' determinations inside the annotated set, and the binary gate has no
+  backbone hook in the processing service. Package G therefore needs an embedding output in the service schema and a
+  `DetectionEmbedding` table that never touches determinations.
+
+## Order for the first dev session
+
+1. **A** first: rank before/after candidates ahead of overlapping ones (or hide overlapping behind a toggle), default
+   to the adjacent captures and let the window grow, apply the cap after that split, multi-select merge, comparison
+   hover, Name/Frames sort. Unblocks three of the seven tests. (Default project filters were the first suspect; the
+   dev project has none, see measurements.)
+2. **B** quick parts: close-on-confirm + next (11), crop grid (8), per-taxon breakdown and detection id/score on the
+   card (3). Edited-vs-verified state (6) needs a migration; do it if time allows.
+3. **D** dry run: cheapest way to answer "what would threshold X do" on a whole session.
+4. **C** click-to-extend, if A's crop comparison component exists by then.
+5. **E/F** are algorithm work; benchmark before and after with the dry run from D.
+
+Each package is its own branch off `integration/tracking-inrae` (or its successor after #1272 merges), PR into it,
+tests + `tsc` + lint per the repo checklists.
+
+## Definition of done per package
+
+- A: a test with an occurrence excluded by taxa filters and one under the score threshold both appear as candidates
+  and can be merged; picker renders a "hidden by project filters" badge; multi-select merges in one request.
+- B: confirm dialog closes and focus moves to the next occurrence; crop grid shows all frames; card lists distinct
+  taxa with counts.
+- C: from the session view with `extend=<id>`, clicking a box adds it and advances; frames already in a multi-frame
+  track prompt to merge the whole track.
+- D: job with `dry_run=true` logs links/tracks/histogram and leaves the database unchanged (assert counts in a test).
+- E: on the benchmark windows, gap-bridging does not add a single cross-species link in the hand-checked set.
+
+## Decisions from hands-on testing (2026-09-15)
+
+- **A detection on a capture the track already covers is a second individual.** One animal cannot appear twice in
+  one capture, so the merge picker never offers such candidates and extend mode refuses the click. They are not shown
+  greyed out: in review they were a distraction.
+- **Candidates that fall in a gap of the track are offered by default**, labelled "In a gap". Their time span overlaps
+  the track's, but they share no capture with it: typically the tracker lost the animal for a few captures and the
+  detector's later boxes became a separate short occurrence.
+- **Later feature: a list of similar or confusing detections.** The co-occurring individuals dropped from the picker
+  are still useful as a separate view, for example "other insects in the same captures" or "look-alikes nearby", to
+  help a reviewer tell two individuals apart. Not scheduled.
diff --git a/docs/claude/planning/2026-09-16-algorithm-outputs-design.md b/docs/claude/planning/2026-09-16-algorithm-outputs-design.md
new file mode 100644
index 000000000..880692a11
--- /dev/null
+++ b/docs/claude/planning/2026-09-16-algorithm-outputs-design.md
@@ -0,0 +1,823 @@
+# Storing algorithm outputs that are not species classifications
+
+Status: design, not yet implemented. Date: 2026-09-16.
+
+## Summary
+
+Antenna can currently only record one kind of machine learning output: a species
+classification. Anything else a model produces — a feature vector, a size estimate, a body
+pose, a caption — has to be squeezed onto a classification row, and a classification row is
+not inert: it competes to become the occurrence's name. This document proposes a small set
+of tables that share one common shape ("an algorithm produced this, about this thing, at
+this time"), a typed table for each output the platform actually acts on, and one
+JSON-backed table for everything else and for experiments. The first of these tables,
+`DetectionEmbedding`, already exists on a local branch and is empty everywhere, so the
+cheapest moment to settle the shape is now.
+
+## Problem
+
+Today every model output is bolted onto `Classification` (`ami/main/models.py:3022`). That
+one row carries the prediction itself (`taxon`, `score`, `terminal`, at
+`ami/main/models.py:3033-3038`), the full raw output of the network (`logits` and `scores`,
+two `float8[]` arrays, `ami/main/models.py:3039-3046`), and the backbone feature vector
+(`features_2048`, a fixed 2048-dimension pgvector column, `ami/main/models.py:3047`).
+
+Three consequences follow.
+
+**A classification is never inert.** `Occurrence.predictions()`
+(`ami/main/models.py:3952`) selects the highest-scoring classification per algorithm, and
+`best_prediction` (`ami/main/models.py:3919`) then orders those by `-terminal, -score`. Any
+extra classification row can therefore change an occurrence's determination, including one
+written only because it was the sole place a vector could be stored. This is not
+theoretical: it has already bitten in fixtures, where a non-terminal probe classification
+outscored the terminal label and silently took over the determination. So storing a vector
+for a crop the moth/non-moth filter rejected — exactly the crops appearance-based tracking
+most needs — is unsafe on the classification table.
+
+**The hot row is not hot.** Measured on the local copy of the production database:
+`main_classification` holds 834,193 rows in a 118 MB heap (about 148 bytes per row), 103 MB
+of indexes, and **4,278 MB of TOAST** — roughly 36 times the heap. 307,663 rows carry
+logits and 309,079 carry softmax scores, so the arrays cost about 14 KB per array-bearing
+row on disk after TOAST compression. The vector is a further ~8 KB per row when present
+(522 rows today). These columns are almost never wanted, but they are easy to drag into a
+query by accident: `.distinct()` on a classification queryset sorts the arrays and turned a
+0.5 s `COUNT` into 208 s on 55,530 rows, and `.defer("features_2048")` does not reach the
+second copy of the table introduced by a `select_related("applied_to")` self-join.
+
+**The vocabulary exists; the storage does not.** `AlgorithmTaskType`
+(`ami/ml/models/algorithm.py:202-221`) already names `embedding`, `size_estimation`,
+`pose_estimation`, `depth_estimation`, `regression`, `captioning` and `tracking`. A
+processing service can declare itself as any of those today. There is nowhere for the
+result to land.
+
+`DetectionEmbedding` (`ami/main/models.py:3429`) is the first output moved out. This design
+generalises from it rather than treating it as a one-off.
+
+## Design
+
+The shape chosen is a shared abstract spine, typed tables for outputs the platform acts on,
+and one generic JSON table for the long tail. The catalogue below says which kind of output
+goes where; the sections after it define the tables it names.
+
+### 1. Output kinds
+
+`AlgorithmTaskType` (`ami/ml/models/algorithm.py:202-221`) already enumerates the kinds of
+model output the platform expects, and it is what a processing service declares itself as.
+Reusing it as the catalogue of output kinds means one vocabulary rather than two, and the
+routing rule becomes simply "task type chooses the table". `outputs[].type` on the wire
+carries these same values (see the wire contract below), and because an algorithm's
+`task_type` is registered, an output whose type contradicts it can be caught on arrival.
+
+| Task type | Output shape and example | Attaches to | Home | Affects determination |
+| --- | --- | --- | --- | --- |
+| `detection` | Box and score, `[0.12, 0.44, 0.31, 0.58]`, `0.87` | capture | `Detection`, existing | No |
+| `localization` | Box or point, as above | capture | `Detection`, existing | No |
+| `segmentation` | Mask polygon, RLE string, or a mask image URL | detection | Generic JSON | No |
+| `classification` | Label, score, full logits, `Noctua pronuba`, `0.94` | detection | `Classification` + `ClassificationScores`, existing | **Yes** |
+| `embedding` | Float vector, 512 / 768 / 2048 wide | detection | Vector table, existing | No |
+| `tracking` | Link between two detections, or a track identifier | occurrence | `Occurrence`, `Detection.next_detection`, existing | No |
+| `tagging` | Non-taxon labels and scores, `["worn", "male"]` | detection | New typed table, early; see the note below | No |
+| `regression` | Scalar with unit and uncertainty, `0.42 g ± 0.05` | detection | `DetectionMeasurement`, new typed table, early | No |
+| `size_estimation` | Scalar with unit, `24.5 mm wingspan` | detection | `DetectionMeasurement`, new typed table, early | No |
+| `depth_estimation` | Depth map URL, or a scalar distance | detection or capture | Generic JSON for a map, `DetectionMeasurement` for a scalar | No |
+| `pose_estimation` | Keypoint list, `[{name, x, y, score}, …]` | detection | Generic JSON | No |
+| `captioning` | Free text, `"a moth resting on a white sheet"` | detection or capture | Generic JSON | No |
+| `generation` | URL to a generated image, or text | detection or capture | Generic JSON | No |
+| `translation` | Text in another language | any | Generic JSON | No |
+| `summarization` | Text summarising a capture or a night | capture or occurrence | Generic JSON | No |
+| `question_answering` | Question and answer text | any | Generic JSON | No |
+| `post_processing` | Varies; today it rewrites a classification | detection | `Classification` via `applied_to`, existing | Yes, by construction |
+| `other` | Anything | any | Generic JSON | No |
+| `unknown` | Anything, from a service that did not declare itself | any | Generic JSON | No |
+
+Only `classification` reaches the determination, and `post_processing` only because it
+produces classifications on purpose. Everything else is inert by construction, which is the
+property this whole design exists to give us.
+
+**Tagging needs a decision.** A tag is a label that must not compete for the name — "worn",
+"male", "in copula". Storing it as a `Classification` with a non-taxon category map is
+tempting because the scoring machinery already exists, but `Occurrence.predictions()`
+(`ami/main/models.py:3952`) does not exclude classifications with a null taxon, so a
+high-scoring tag would be returned by `best_prediction` exactly as a species label is. The
+recommendation is a small typed table of its own, sharing the spine, with a label and a
+score. That is a reading of the code rather than a tested claim, and worth confirming
+before building either version.
+
+### 2. The spine: an abstract `AlgorithmOutput` base model
+
+An abstract Django model (no table of its own) that every output table inherits, so the
+provenance fields are named and typed identically everywhere and a reader can be written
+once against the shape.
+
+**Refined 2026-09-22 — build from the worked examples at the end of this document, not from
+the table immediately below.** Writing the models out moved the three target fields off the
+spine: `get_project_accessor()` (`ami/base/models.py:99`) returns a single path, so a table
+that genuinely mixes targets cannot resolve one, and permission filtering needs it. The
+spine therefore carries provenance only (`algorithm`, `timestamp`, `job`), and each concrete
+table declares the one thing it is about together with its own `project_accessor`, exactly
+as `Classification` and `DetectionEmbedding` already do. Only the generic table carries all
+three targets, with the check constraint below.
+
+| Field | Type | Notes |
+| --- | --- | --- |
+| `detection` | FK `Detection`, `null=True`, `CASCADE` | One of the three targets |
+| `source_image` | FK `SourceImage`, `null=True`, `CASCADE` | Capture-level outputs |
+| `occurrence` | FK `Occurrence`, `null=True`, `CASCADE` | Occurrence-level outputs |
+| `algorithm` | FK `ml.Algorithm`, `CASCADE` | Which model produced it |
+| `timestamp` | `DateTimeField` | When the model produced it |
+| `job` | FK `jobs.Job`, `null=True`, `SET_NULL` | Which run wrote it, for auditing |
+| `created_at`, `updated_at` | inherited from `BaseModel` (`ami/base/models.py:91`) | |
+
+A check constraint on each concrete table requires exactly one of the three targets to be
+non-null.
+
+Two honest complications. First, `get_project_accessor()` (`ami/base/models.py:99`) is a
+classmethod returning a single path, so a table that genuinely mixes targets has no single
+project accessor and would not filter correctly for permissions; the recommendation is that
+each of the first tables targets exactly one thing and declares its own accessor, as
+`Classification` and `DetectionEmbedding` both already do. Second, `Classification` has no
+`job` field today (there is a commented-out one at `ami/main/models.py:3060`), so adopting
+the spine adds a nullable column to the largest of these tables — cheap, but its own PR.
+
+### 3. Typed tables for outputs the platform acts on
+
+An output earns a table when the UI, a filter, or a background job reads individual fields
+of it.
+
+| Table | Target | Fields | Status |
+| --- | --- | --- | --- |
+| `Classification` | detection | `taxon`, `score`, `terminal`, `category_map`, `applied_to` | Exists; stays. It is what determinations read. |
+| `ClassificationScores` | — (1:1 off `Classification`) | `logits`, `scores` | New; moves the two arrays off the hot row |
+| `DetectionEmbedding` | detection | `vector` | Exists on `feat/detection-embeddings`, empty |
+| `DetectionMeasurement` | detection | `kind`, `value`, `unit`, `uncertainty` | Future; the worked example below |
+
+`ClassificationScores` is a side table keyed on the classification (a `OneToOneField` used
+as the primary key), not an inheritor of the spine — the arrays belong to one specific
+prediction, not to an independent observation. Moving them leaves `Classification` at
+roughly its 148-byte heap row and makes the arrays opt-in through an explicit join, which
+no accidental `.distinct()` or `select_related` can pull in.
+
+**Decided 2026-09-22: the move also shrinks what is kept and drops what is derivable.**
+Two changes ride along with stage (b), because the backfill rewrites every one of these
+rows once and there is no reason to rewrite them twice.
+
+*Shrink the logits to four bytes per class.* `logits` is `float8[]`, eight bytes per class,
+and a model's raw output does not need double precision. pgvector's `vector` holds
+four-byte floats and is already installed, so a dimensionless `vector` column halves the
+bytes with no new dependency. Two caveats to settle first: pgvector rejects `NaN` and
+infinity where `float8[]` accepts them, which matters because a masked class can legitimately
+emit `-inf`; and a `vector` reads back as a numpy array, so every call site of
+`top_scores_with_index()` and `predictions()` (`ami/main/models.py:3090-3115`) has to
+tolerate that. If the `-inf` check fails, keep `float4[]`, which still halves the bytes.
+
+*Drop `scores` as redundant.* The softmax scores are a pure function of the logits, so
+storing both doubles the cost of the most expensive column in the database to save one
+cheap computation. Keep `logits`, compute the scores on read.
+
+One caveat that has to be handled in the migration rather than waved past: the two columns
+are not populated together. 307,663 rows carry logits and **309,079 carry scores**, so
+roughly 1,400 rows have scores with no logits behind them, and for those the scores cannot
+be recomputed. Find them first, and either keep their scores or accept the loss knowingly;
+do not discover them by deleting the column.
+
+`DetectionMeasurement` is sketched rather than built now. One scalar with a unit covers
+wingspan, body length, estimated mass and distance, and it is the kind of output a user
+would want to sort and filter on, which is the test for deserving a table.
+
+### 4. One generic table for everything else
+
+| Field | Type | Notes |
+| --- | --- | --- |
+| (spine fields) | | target, algorithm, timestamp, job |
+| `output_type` | `CharField`, indexed | An `AlgorithmTaskType` value; see the catalogue above |
+| `data` | `JSONField` (JSONB) | Validated on write against a per-type pydantic schema |
+
+A module-level registry maps `output_type` to a pydantic model, and the save path validates
+`data` against it before writing. An unregistered type is stored as-is, so a processing
+service experimenting with a new output is never blocked on an Antenna deploy; it simply
+gets no validation and no UI until someone registers the type.
+
+**What must not go in here**, stated plainly because the table will otherwise become the
+path of least resistance:
+
+- **Vectors and logits.** JSONB stores floats as text, so a 2048-float vector is roughly
+  25 KB here against 8 KB as `vector`, it cannot be indexed for similarity, and the "one
+  feature extractor per similarity query" rule cannot be enforced on an untyped blob.
+- **Anything a user filters or sorts on.** A JSONB expression index is possible but it is a
+  per-key decision made after the fact, and it will not be made. Promote the type instead.
+- **Anything the determination logic reads.** Determinations read `Classification` and
+  nothing else, and that should stay true.
+
+Promotion from generic to typed is the expected lifecycle, not a failure; the generic table
+is where a type lives while we find out whether anyone uses it.
+
+### 5. Wire contract
+
+`DetectionResponse` (`ami/ml/schemas.py:204`) gains one generic field beside
+`classifications`:
+
+```
+outputs: list[AlgorithmOutputResponse] | None
+  AlgorithmOutputResponse = { algorithm: AlgorithmReference, type: str, data: dict }
+```
+
+`type` carries an `AlgorithmTaskType` value, the same vocabulary a service already uses for
+`AlgorithmConfigResponse.task_type` (`ami/ml/schemas.py:101`), and Antenna routes on it
+straight from the catalogue in section 1.
+
+Three rules on arrival. An algorithm key the service did not declare in `/info` fails the
+whole batch with `PipelineNotConfigured`, as `create_detection_embeddings` already does
+(`ami/ml/models/pipeline.py:718-724`). An output whose `type` contradicts its algorithm's
+registered `task_type` (`ami/ml/models/algorithm.py:233`) — a classifier sending a pose,
+say — is caught here; whether it warns or fails is an open question below. An unrecognised
+`type` never fails; it goes to the generic table.
+
+Capture-level and occurrence-level outputs get the same field on their own response models
+when a service needs them. None does yet, so that is deferred.
+
+**Recommendation: keep `embeddings` as its own typed field** (`ami/ml/schemas.py:212`)
+rather than folding vectors into `outputs`. A vector inside `data: dict` is JSON-encoded
+floats, roughly three times the bytes on the wire, with no width check at the boundary —
+`EmbeddingResponse` validates the length today (`ami/ml/schemas.py:197-201`), and that is
+the only thing between a misconfigured service and a table of unusable vectors. Same
+reasoning as the "no vectors in the generic table" rule, applied to the wire.
+
+Whatever is added here, `ami/ml/schemas.py` must stay free of Antenna-side concepts: no
+projects, users, or permissions. A task type names a kind of model output, not an Antenna
+feature, which is part of why it is safe to share as the routing vocabulary.
+
+### 6. Changes to make to the vector table now, while it is empty
+
+`DetectionEmbedding` exists only on a local branch (migration `0101_detection_embedding.py`)
+and holds no rows anywhere. These changes cost nothing today and a data migration later.
+
+1. **Rename `features_2048` to `vector`** (`ami/main/models.py:3442`). The name encodes a
+   width that is already wrong for other backbones — 768 and 512 are both common.
+2. **Drop the fixed width.** `VectorField()` with no `dimensions` maps to Postgres `vector`,
+   which accepts any width in the same column ([pgvector README](https://github.com/pgvector/pgvector)).
+   Antenna does not choose the width; the model does.
+3. **Validate the width per algorithm.** The proposal is a nullable
+   `Algorithm.output_dimensions` integer (`ami/ml/models/algorithm.py:228`), populated from
+   a matching field on `AlgorithmConfigResponse`, and checked on write. The category map is
+   not the right home: it describes labels, and an embedding algorithm has no labels. This
+   is an ML-backend schema addition, which is legitimate because the dimension is a property
+   of the model rather than of Antenna.
+4. **Keep unique `(detection, algorithm)`** (`ami/main/models.py:3448-3451`) — one vector per
+   detection per model, replaced on reprocessing.
+5. **Similarity indexes as per-algorithm partial expression indexes with a cast**, which is
+   the documented pattern for a dimensionless column:
+   `CREATE INDEX ... USING hnsw ((vector::vector(512)) vector_cosine_ops) WHERE algorithm_id = 7`.
+   This is also the only index shape consistent with the domain rule that vectors from
+   different algorithms are never comparable. Note the caps: an indexed `vector` is limited
+   to 2,000 dimensions and an indexed `halfvec` to 4,000, so a 2048-dimension backbone
+   cannot be indexed as `vector` and needs `halfvec`, which arrived in pgvector 0.7.0.
+
+   **Decided 2026-09-22: upgrade the extension, and treat 0.7.0 or later as the baseline.**
+   This is cheaper than it first looked. Measured on the local stack: the database has
+   pgvector **0.5.1** installed while the image already provides **0.8.6**, so the upgrade is
+   `ALTER EXTENSION vector UPDATE;` — no image change, no dump, no data migration. Postgres
+   itself is 16.15. Two `vector(2048)` columns exist today,
+   `main_classification.features_2048` and `main_detectionembedding.features_2048`, and an
+   extension update leaves both as they are; `halfvec` simply becomes available for new
+   columns.
+
+   With the upgrade assumed, the width question stops being about whether an index is
+   possible at all and becomes an ordinary size and quality trade-off: 1024 dimensions costs
+   about 4 KB a row against 8 KB at 2048, indexes as a plain `vector` with no `halfvec`
+   needed, and scans faster. Choose the width on retrieval quality, not on the extension.
+
+   Confirm the deployed databases before relying on this. Production and staging declare no
+   postgres service of their own (`docker-compose.production.yml`,
+   `docker-compose.staging.yml`), so their database is managed externally and the upgrade
+   there is an operations task rather than an image bump. The local result does not carry
+   over to them on its own.
+
+## Sizes and scale
+
+All figures below are **estimates from the storage formats**, except the ones explicitly
+marked measured. pgvector stores four bytes per dimension plus an eight-byte header;
+`float8[]` stores eight bytes per element plus about 24 bytes of array header.
+
+| Item | Per row | 10 M rows |
+| --- | --- | --- |
+| `vector`, 2048 dims | ~8.0 KB | ~80 GB |
+| `vector`, 768 dims | ~3.0 KB | ~30 GB |
+| `vector`, 512 dims | ~2.0 KB | ~20 GB |
+| `logits` + `scores`, 29,176 classes, float8 | ~467 KB | ~4.7 TB |
+| `logits` + `scores`, 2,497 classes, float8 | ~40 KB | ~400 GB |
+| Same at four bytes per class | half the above | half the above |
+| `Classification` heap row without arrays or vector | ~148 B (measured) | ~1.5 GB |
+
+Both class counts are real: the local database holds category maps of 29,176 and 2,497
+labels (`ml_algorithmcategorymap` ids 51 and 12), along with 5,952, 3,045 and 2,603.
+
+The table overstates disk, because TOAST compresses. Measured on the local production copy:
+834,193 classifications, of which 307,663 carry logits, occupy **4,278 MB of TOAST against
+a 118 MB heap** — about 14 KB per array-bearing row. Extrapolating linearly (weakly, since
+the mix of algorithms would change), 10 M such rows would be roughly 140 GB of TOAST.
+
+The ratio matters more than the absolute size: the arrays are 36 times the heap on the same
+table, and they should not sit where an ordinary query can reach them.
+
+## Migration path
+
+Each stage is its own pull request, and each is independently useful.
+
+**(a) Vector table rename and the spine.** Rename `features_2048` to `vector`, drop the
+fixed width, add `Algorithm.output_dimensions`, introduce the abstract base and apply it to
+`DetectionEmbedding`. No data exists, so there is nothing to backfill. Needs from the
+processing services: the dimension declared in the `/info` algorithm config, and
+`EmbeddingResponse.features` relaxed from a hard 2048 to a check against it.
+
+Also in (a), two clean-ups on `Detection` itself (`ami/main/models.py:3262-3272`):
+
+- **Drop `Detection.similarity_vector`.** A `JSONField` placeholder from the initial models
+  commit with no reader, writer, serializer or processing-service field, and no data: 0 of
+  642,729 rows on a copy of production carry a value. One migration, nothing to move.
+- **Populate `Detection.detection_score`, and keep it on `Detection`.** The detector's box
+  confidence belongs beside the box and the detector's `algorithm`, which already live on the
+  detection, so it is not an output-table candidate. Today the column is never written, and
+  neither `DetectionResponse` in Antenna (`ami/ml/schemas.py:206-216`) nor in the processing
+  service carries a score, so the contract gains an optional `score` on `DetectionResponse`
+  on both sides and `create_detections` stores it. Optional, so an older service that omits
+  it still works; the column stays null for those rows.
+
+**(b) Logits side table, shrunk, with the scores dropped.** Create `ClassificationScores`,
+write to it, and make the read path fall back to `Classification.logits` / `.scores` when
+there is no side row. Backfill in batches — 307,663 rows and 4.2 GB of TOAST is not an
+instant `UPDATE`. Drop the old columns in a later PR, once the fallback has gone unused in
+production for a while. No processing-service change.
+
+The backfill rewrites every one of these rows once, so it carries the two size decisions
+with it rather than rewriting them again later:
+
+- Store the logits at **four bytes per class**, not eight, which halves the largest column
+  in the database. Settle the `-inf` question first: if pgvector's rejection of infinity is
+  a problem for masked classes, use `float4[]` and keep the halving.
+- **Do not store the softmax scores at all.** They are a pure function of the logits, so
+  keeping both doubles the cost of that column to save one cheap computation on read.
+- **Audit the ~1,400 rows that have scores and no logits first** (309,079 against 307,663).
+  Their scores cannot be recomputed from anything. Decide what happens to them before the
+  column is dropped, not after.
+
+**(c) Generic outputs table and `outputs` on the wire.** Add `AlgorithmOutputRecord`, the
+type registry, and the `outputs` field on `DetectionResponse`; route by task type in
+`save_results` (`ami/ml/models/pipeline.py:1076`). The field is optional, so nothing breaks
+for a service that never sends it.
+
+**(d) First measurement type.** Add `DetectionMeasurement` and one real producer, which is
+what proves the routing works end to end. Needs from the processing services: a size
+estimator declaring `task_type: "size_estimation"` and emitting a measurement output.
+
+Stages (a) and (b) touch models, so each carries its own migration in the same PR.
+
+## What we still need to verify
+
+None of the performance claims here have been measured on the proposed design; they are
+read off storage formats and off the current table. Before each stage lands:
+
+1. **`EXPLAIN (ANALYZE)` the partial expression index.** Build one on a dimensionless
+   `vector` column for a single algorithm, on a realistically sized table rather than an
+   empty one, and confirm the planner matches both the cast and the `WHERE algorithm_id = N`
+   predicate instead of scanning.
+2. **Measure a hot classification query before and after the logits move.** Take an
+   occurrence list and an occurrence detail, capture the SQL under `cachalot_disabled()`,
+   and record wall time both ways on the largest local project. A claim that the move helps
+   is worth nothing without the pair of numbers.
+3. **Round-trip an unrecognised task type** from a processing service through `save_results`
+   and confirm it lands in the generic table, that an unknown *algorithm* key still raises
+   `PipelineNotConfigured`, and that neither path creates a `Classification` or changes any
+   occurrence's determination.
+4. **Confirm pgvector rejects nothing we send.** If `scores` or `logits` move to a `vector`
+   column, check what real models emit — a `-inf` logit from a masked class would be
+   rejected where a `float8[]` accepted it.
+5. **Run the pgvector upgrade and confirm it on each deployment.** The decision is to be on
+   0.7.0 or later, and locally that is `ALTER EXTENSION vector UPDATE;` because the image
+   already carries 0.8.6 against 0.5.1 installed. What still needs checking per deployment is
+   that its image offers the same, and that the update completes with the existing
+   `vector(2048)` columns in place.
+
+## Open questions
+
+- Should `Classification` adopt the spine at all, or should the spine describe only the new
+  tables? Adopting it adds a `job` column to the largest table for uniformity's sake, and
+  uniformity may not be worth that.
+- Where does a capture-level or occurrence-level output come from on the wire? The current
+  response is detection-shaped, and an output about the whole capture has no natural home in
+  it.
+- Should `ClassificationResponse.features` (`ami/ml/schemas.py:136`) be deprecated once
+  `embeddings` is established, and if so, on what timeline for the services still sending it?
+- Does a re-run of an algorithm replace an output or append a new one? `DetectionEmbedding`
+  replaces, via the unique constraint. A measurement might reasonably want history.
+- Is a tag its own table or a `Classification` with a non-taxon category map? See the note
+  in the catalogue; the recommendation is its own table, and it should be confirmed.
+- Should an output whose `type` contradicts its algorithm's registered `task_type` warn or
+  fail the batch? Failing is safer and blocks a service mid-experiment.
+- `AlgorithmTaskType` is the vocabulary, so adding a kind of output means adding an enum
+  value. Who agrees a new value, and does an Antenna deploy have to precede a service using
+  it? The generic table softens this, since an unrecognised type is still stored.
+
+## References
+
+- pgvector, dimension limits, dimensionless columns and expression indexes:
+  <https://github.com/pgvector/pgvector>
+- `Classification`: `ami/main/models.py:3022`; `logits`/`scores`/`features_2048`:
+  `ami/main/models.py:3039-3051`
+- `DetectionEmbedding`: `ami/main/models.py:3429`; migration
+  `ami/main/migrations/0101_detection_embedding.py`
+- Vector reader, one algorithm at a time: `ami/main/models_future/embeddings.py`
+- Determination logic: `Occurrence.best_prediction` `ami/main/models.py:3919`,
+  `Occurrence.predictions` `ami/main/models.py:3952`
+- Wire schemas: `EmbeddingResponse` `ami/ml/schemas.py:185`, `DetectionResponse`
+  `ami/ml/schemas.py:204`, `ClassificationResponse` `ami/ml/schemas.py:124`
+- Save path: `create_detection_embeddings` `ami/ml/models/pipeline.py:687`,
+  `create_classifications` `ami/ml/models/pipeline.py:922`, `save_results`
+  `ami/ml/models/pipeline.py:1076`
+- `AlgorithmTaskType` and `Algorithm`: `ami/ml/models/algorithm.py:202`, `:228`
+
+---
+
+## Worked examples
+
+Everything below is written against the code as it stands, so it can be read beside the current models rather than translated. Names are proposals, not decisions.
+
+### The shape, as tables
+
+```mermaid
+erDiagram
+    ALGORITHM ||--o{ CLASSIFICATION : produced
+    ALGORITHM ||--o{ DETECTION_EMBEDDING : produced
+    ALGORITHM ||--o{ DETECTION_MEASUREMENT : produced
+    ALGORITHM ||--o{ ALGORITHM_OUTPUT_RECORD : produced
+
+    DETECTION ||--o{ CLASSIFICATION : "about"
+    DETECTION ||--o{ DETECTION_EMBEDDING : "about"
+    DETECTION ||--o{ DETECTION_MEASUREMENT : "about"
+    DETECTION ||--o{ ALGORITHM_OUTPUT_RECORD : "about"
+
+    CLASSIFICATION ||--o| CLASSIFICATION_SCORES : "raw arrays moved here"
+    CLASSIFICATION }o--o| TAXON : names
+
+    OCCURRENCE ||--o{ DETECTION : groups
+    OCCURRENCE }o--o| TAXON : "determination, read ONLY from CLASSIFICATION"
+
+    ALGORITHM {
+        slug key
+        string task_type "routes the output to its table"
+        int output_dimensions "new, nullable"
+    }
+    CLASSIFICATION {
+        bigint detection_id
+        bigint taxon_id
+        float score
+        bool terminal
+    }
+    CLASSIFICATION_SCORES {
+        bigint classification_id PK "1:1"
+        vector logits "4 bytes a class, was float8[]"
+    }
+    DETECTION_EMBEDDING {
+        bigint detection_id
+        bigint algorithm_id
+        vector vector "dimensionless"
+    }
+    DETECTION_MEASUREMENT {
+        bigint detection_id
+        string kind
+        float value
+        string unit
+        float uncertainty
+    }
+    ALGORITHM_OUTPUT_RECORD {
+        bigint detection_id "one of three targets"
+        bigint source_image_id
+        bigint occurrence_id
+        string output_type
+        jsonb data
+    }
+```
+
+The one rule the diagram encodes: the determination reads `CLASSIFICATION` and nothing else. Every other table is inert by construction.
+
+### Example schema
+
+Note for anyone reading the DDL against a live database: this project runs with `USE_TZ = False`, so these are `timestamp without time zone`, not `timestamptz`.
+
+```sql
+-- One vector per detection per algorithm. The width is the model's business, not ours,
+-- so the column is dimensionless and each algorithm declares what it emits.
+CREATE TABLE main_detectionembedding (
+    id           bigserial PRIMARY KEY,
+    created_at   timestamp NOT NULL,
+    updated_at   timestamp NOT NULL,
+    timestamp    timestamp NOT NULL,
+    detection_id bigint NOT NULL REFERENCES main_detection(id) ON DELETE CASCADE,
+    algorithm_id bigint NOT NULL REFERENCES ml_algorithm(id)   ON DELETE CASCADE,
+    job_id       bigint NULL     REFERENCES jobs_job(id)       ON DELETE SET NULL,
+    vector       vector NOT NULL,
+    CONSTRAINT unique_detection_embedding_per_algorithm UNIQUE (detection_id, algorithm_id)
+);
+
+-- Similarity is only meaningful within one algorithm, so the index says so out loud.
+-- The cast is what a dimensionless column needs; the predicate is the domain rule.
+CREATE INDEX detectionembedding_hnsw_algo_7
+    ON main_detectionembedding
+    USING hnsw ((vector::vector(1024)) vector_cosine_ops)
+    WHERE algorithm_id = 7;
+
+-- The raw arrays leave the hot row. Keyed on the classification, so it is a join
+-- nobody makes by accident, rather than a column a careless select_related drags in.
+CREATE TABLE main_classificationscores (
+    classification_id bigint PRIMARY KEY REFERENCES main_classification(id) ON DELETE CASCADE,
+    created_at        timestamp NOT NULL,
+    updated_at        timestamp NOT NULL,
+    logits            vector NOT NULL
+);
+
+-- The long tail. One row per output, validated per type on write.
+CREATE TABLE main_algorithmoutputrecord (
+    id              bigserial PRIMARY KEY,
+    created_at      timestamp NOT NULL,
+    updated_at      timestamp NOT NULL,
+    timestamp       timestamp NOT NULL,
+    algorithm_id    bigint NOT NULL REFERENCES ml_algorithm(id) ON DELETE CASCADE,
+    job_id          bigint NULL REFERENCES jobs_job(id) ON DELETE SET NULL,
+    detection_id    bigint NULL REFERENCES main_detection(id)   ON DELETE CASCADE,
+    source_image_id bigint NULL REFERENCES main_sourceimage(id) ON DELETE CASCADE,
+    occurrence_id   bigint NULL REFERENCES main_occurrence(id)  ON DELETE CASCADE,
+    output_type     varchar(255) NOT NULL,
+    data            jsonb NOT NULL,
+    CONSTRAINT exactly_one_target CHECK (
+        (detection_id IS NOT NULL)::int
+      + (source_image_id IS NOT NULL)::int
+      + (occurrence_id IS NOT NULL)::int = 1
+    )
+);
+
+CREATE INDEX algorithmoutputrecord_type_idx ON main_algorithmoutputrecord (output_type);
+```
+
+### Model definitions
+
+**A refinement of the design document, with a reason.** The document sketched the spine as carrying all three target foreign keys. Writing it out against `BaseModel.get_project_accessor()` shows why that only suits the generic table: the accessor is a single classmethod path, so a table that genuinely mixes targets has no one path and will not filter correctly for permissions. So the spine carries provenance only, and each concrete table declares the target it is about along with its own `project_accessor`, exactly as `Classification` and `DetectionEmbedding` already do.
+
+```python
+class AlgorithmOutput(BaseModel):
+    """What a model said, by whom, and when. Abstract: it owns provenance, not the target.
+
+    Concrete tables declare the thing the output is about, because `project_accessor`
+    is a single path and a table mixing targets cannot resolve one.
+    """
+
+    algorithm = models.ForeignKey(
+        "ml.Algorithm", on_delete=models.CASCADE, related_name="%(class)ss"
+    )
+    timestamp = models.DateTimeField(help_text="When the model produced this")
+    job = models.ForeignKey(
+        "jobs.Job", on_delete=models.SET_NULL, null=True, blank=True,
+        related_name="%(class)ss", help_text="The run that wrote it, for auditing",
+    )
+
+    class Meta:
+        abstract = True
+
+
+class DetectionEmbedding(AlgorithmOutput):
+    """A feature vector for one detection from one algorithm.
+
+    Apart from classifications so every detection can have one, including those the
+    moth/non-moth filter rejected, without adding a prediction that could change a
+    determination. Vectors compare only within one algorithm.
+    """
+
+    project_accessor = "detection__source_image__project"
+
+    # No separate index: the unique constraint's index leads with detection_id.
+    detection = models.ForeignKey(
+        Detection, on_delete=models.CASCADE, related_name="embeddings", db_index=False
+    )
+    vector = pgvector.django.VectorField(
+        help_text="Backbone embedding. Dimensionless: the algorithm declares its width."
+    )
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["detection", "algorithm"],
+                name="unique_detection_embedding_per_algorithm",
+            )
+        ]
+
+
+class DetectionMeasurement(AlgorithmOutput):
+    """One scalar a model measured about a detection: wingspan, body length, mass."""
+
+    project_accessor = "detection__source_image__project"
+
+    detection = models.ForeignKey(
+        Detection, on_delete=models.CASCADE, related_name="measurements"
+    )
+    kind = models.CharField(max_length=255, help_text="wingspan, body_length, mass")
+    value = models.FloatField()
+    unit = models.CharField(max_length=32, help_text="mm, g")
+    uncertainty = models.FloatField(null=True, blank=True)
+
+
+class AlgorithmOutputRecord(AlgorithmOutput):
+    """Everything with no table of its own yet, and everything experimental.
+
+    Promotion to a typed table is the expected end of a type's life here, not a failure.
+    """
+
+    project_accessor = "detection__source_image__project"
+
+    detection = models.ForeignKey(
+        Detection, on_delete=models.CASCADE, null=True, blank=True, related_name="outputs"
+    )
+    source_image = models.ForeignKey(
+        SourceImage, on_delete=models.CASCADE, null=True, blank=True, related_name="outputs"
+    )
+    occurrence = models.ForeignKey(
+        Occurrence, on_delete=models.CASCADE, null=True, blank=True, related_name="outputs"
+    )
+    output_type = models.CharField(
+        max_length=255, db_index=True,
+        choices=[t.as_choice() for t in AlgorithmTaskType],
+    )
+    data = models.JSONField(help_text="Validated against the schema registered for output_type")
+
+    def save(self, *args, **kwargs):
+        schema = OUTPUT_SCHEMAS.get(self.output_type)
+        if schema is not None:
+            # An unregistered type is stored as-is: a service trying a new output is
+            # never blocked on an Antenna deploy, it just gets no validation and no UI.
+            self.data = schema(**self.data).dict()
+        return super().save(*args, **kwargs)
+```
+
+The algorithm declares its own width, which is what makes a dimensionless column safe:
+
+```python
+class Algorithm(BaseModel):
+    ...
+    output_dimensions = models.IntegerField(
+        null=True, blank=True,
+        help_text="Width of the vector this algorithm emits, when it emits one.",
+    )
+```
+
+### ORM usage
+
+**Writing, on the save path.** One statement for a batch, with re-processing replacing rather than duplicating, which is what the unique constraint is for:
+
+```python
+DetectionEmbedding.objects.bulk_create(
+    [
+        DetectionEmbedding(
+            detection_id=detection_id,
+            algorithm=algorithm,
+            vector=vector,
+            timestamp=response.timestamp,
+            job_id=job_id,
+        )
+        for detection_id, vector in vectors.items()
+    ],
+    update_conflicts=True,
+    unique_fields=["detection", "algorithm"],
+    update_fields=["vector", "timestamp", "job"],
+)
+```
+
+**Reading. The migration is one function, which is the point.** Tracking reads vectors through `latest_feature_vectors()` in `ami/ml/post_processing/tracking_task.py:379`. It reads classifications today:
+
+```python
+# today
+rows = (
+    Classification.objects.filter(
+        detection_id__in=list(detection_ids),
+        algorithm_id=algorithm_id,
+        features_2048__isnull=False,
+    )
+    .order_by("-timestamp", "-pk")
+    .values_list("detection_id", "features_2048")
+)
+```
+
+and would read the vector table instead, keeping the same signature and the same one-query-per-batch promise. The unique constraint removes the need to pick a winner per detection:
+
+```python
+# proposed
+rows = (
+    DetectionEmbedding.objects.filter(
+        detection_id__in=list(detection_ids),
+        algorithm_id=algorithm_id,
+    )
+    .values_list("detection_id", "vector")
+)
+```
+
+`resolve_feature_algorithm()` (`tracking_task.py:149`) is unchanged: it already returns a single algorithm, and every query stays pinned to it. That rule is not advice here, it is the shape of the index.
+
+**Similarity, pinned to one algorithm.** The pin is required for correctness, and it is also what lets the partial index match:
+
+```python
+from pgvector.django import CosineDistance
+
+neighbours = (
+    DetectionEmbedding.objects.filter(algorithm_id=algorithm_id)
+    .exclude(detection_id=detection_id)
+    .annotate(distance=CosineDistance("vector", query_vector))
+    .order_by("distance")
+    .values_list("detection_id", "distance")[:20]
+)
+```
+
+**Not reading the arrays, which is the whole point of the side table.** Today an incautious query can drag 4.2 GB of arrays along. Afterwards they are simply not on the row, and asking for them is explicit:
+
+```python
+scores = ClassificationScores.objects.filter(classification_id=classification.pk).first()
+```
+
+### API design and usage
+
+**On the wire, from a processing service.** `DetectionResponse` (`ami/ml/schemas.py:204`) gains one optional field beside `classifications`, and vectors keep their own typed field, because a vector inside `data` is JSON-encoded floats at roughly three times the bytes with no width check at the boundary:
+
+```python
+class AlgorithmOutputResponse(pydantic.BaseModel):
+    algorithm: AlgorithmReference
+    type: str                  # an AlgorithmTaskType value
+    data: dict[str, typing.Any]
+
+
+class DetectionResponse(pydantic.BaseModel):
+    ...
+    classifications: list[ClassificationResponse] | None = None
+    embeddings: list[EmbeddingResponse] | None = None
+    outputs: list[AlgorithmOutputResponse] | None = None   # new
+```
+
+A service posting a pose alongside its classification:
+
+```json
+{
+  "source_image_id": "12345",
+  "bbox": [0.12, 0.44, 0.31, 0.58],
+  "outputs": [
+    {
+      "algorithm": { "key": "moth-pose-v2" },
+      "type": "pose_estimation",
+      "data": { "keypoints": [{ "name": "head", "x": 0.21, "y": 0.47, "score": 0.88 }] }
+    }
+  ]
+}
+```
+
+Three rules on arrival, the first of which already exists for embeddings: an algorithm key the service never declared in `/info` fails the batch with `PipelineNotConfigured`; an output whose `type` contradicts its algorithm's registered `task_type` is caught here, and whether it warns or fails is still open; an unrecognised `type` never fails, it goes to the generic table.
+
+**Reading it back.** Following the conventions already used by `merge_candidates` (`ami/main/api/views.py:1857`): an action on the occurrence viewset, parameters parsed through `SingleParamSerializer` so bad input is a 400 rather than a 500, and the response typed for the schema.
+
+```python
+@extend_schema(
+    parameters=[OpenApiParameter(name="type", type=OpenApiTypes.STR, required=False)],
+    responses=AlgorithmOutputSerializer(many=True),
+)
+@action(detail=True, methods=["get"], name="outputs", url_path="outputs")
+def outputs(self, request: Request, pk=None) -> Response:
+    """Everything models recorded about this occurrence's detections, except its species.
+
+    Classifications are not returned here: they are the determination, and they have
+    their own place in the occurrence payload.
+    """
+    occurrence = self.get_object()
+    output_type = SingleParamSerializer[str].clean(
+        param_name="type",
+        serializer_class=serializers.ChoiceField,
+        serializer_kwargs={"choices": [t.value for t in AlgorithmTaskType], "required": False},
+        request=request,
+    )
+    queryset = AlgorithmOutputRecord.objects.filter(
+        detection__occurrence=occurrence
+    ).select_related("algorithm")
+    if output_type:
+        queryset = queryset.filter(output_type=output_type)
+    return Response(AlgorithmOutputSerializer(queryset, many=True).data)
+```
+
+```
+GET /api/v2/occurrences/634532/outputs/?type=pose_estimation
+```
+
+```json
+[
+  {
+    "id": 91,
+    "detection_id": 668170,
+    "algorithm": { "id": 7, "key": "moth-pose-v2", "name": "Moth Pose v2", "task_type": "pose_estimation" },
+    "type": "pose_estimation",
+    "timestamp": "2026-09-22T21:14:03",
+    "data": { "keypoints": [{ "name": "head", "x": 0.21, "y": 0.47, "score": 0.88 }] }
+  }
+]
+```
+
+Vectors deliberately get no such endpoint. They are large, they are only comparable within one algorithm, and nothing in the interface reads a raw vector. What the interface needs is whether one exists, which the occurrence payload already answers with `frames_with_vectors`.
diff --git a/docs/claude/planning/idempotent-incremental-tracking.md b/docs/claude/planning/idempotent-incremental-tracking.md
new file mode 100644
index 000000000..21fbf0a8a
--- /dev/null
+++ b/docs/claude/planning/idempotent-incremental-tracking.md
@@ -0,0 +1,616 @@
+# Idempotent, incremental occurrence tracking
+
+Status: design proposal, not implemented. Written 2026-09-02.
+
+## The problem
+
+Occurrence tracking today is a batch operation an operator runs over a whole session: it walks
+every pair of consecutive captures, links detections that look like the same insect, and folds
+each resulting chain into a single occurrence. Because re-running it over data that has already
+been grouped can delete occurrences that carry human identifications, it is guarded by
+`require_fresh_event`, which refuses any session where an occurrence already spans more than one
+detection. That guard makes the operation single-shot: a session can be tracked once, and only
+before anyone has touched it. It also leaves an unanswerable question at the centre of the design
+— when is a session finished? — because most processing runs are deliberately samples, so "every
+capture has been processed" is a state that frequently never arrives. This document proposes
+replacing the batch pass with one that is always safe to run, any number of times, at any point:
+the unit of work becomes a single pair of adjacent processed captures, running twice does nothing
+the second time, and running after more captures arrive picks up only the new work.
+
+## Evidence that reframes the problem
+
+Three measurements against the local database (a copy of production) shaped the design more than
+anything in the code. Session identifiers are omitted because this repository is public.
+
+**Sampling is the norm, not the exception.** The session with the most processed captures in the
+local database holds 4,497 captures, of which 750 have any detection at all — 17%. The session
+with the most captures holds 23,362, of which 65 are processed — 0.3%. Across the ten
+most-processed sessions the share never exceeds 17%. Measured. This is the empirical form of the
+user's point: waiting for a session to be complete is waiting for something that does not happen.
+
+**Adjacent processed captures are minutes apart, not seconds.** In these sessions the camera
+captures every 10 seconds, but the processed subset is a uniform sample: the median gap between
+one processed capture and the next is 60 seconds in five of the sessions measured, 45 seconds in
+one, and 600 seconds in another. Measured. The current cost function assumes small motion between
+frames, and this is discussed under "What I am unsure about" below, because it has consequences
+well beyond this design.
+
+**The current implementation is close to a no-op on sampled sessions.**
+`assign_occurrences_by_tracking_images` builds its sequence from `event.captures.order_by("timestamp")`
+— every capture, processed or not (`ami/ml/post_processing/tracking_task.py:358`). On a session
+where 65 of 23,362 captures carry detections, almost every one of the 23,361 transitions it
+evaluates is between two captures with no detections, and two processed captures are almost never
+adjacent to each other, so almost no links can be created. This is a pre-existing defect rather
+than something the redesign introduces, but the fix falls out of the redesign: adjacency has to be
+defined over processed captures.
+
+## The design
+
+### The unit of work is a transition between two processed captures
+
+Order a session's *processed* captures by timestamp. Each consecutive pair is a **transition**.
+Evaluating a transition means running the existing greedy matcher over the detections of the two
+captures and writing `Detection.next_detection` links for the matches it accepts. A capture counts
+as processed when at least one `Detection` row references it, including a null-marker sentinel —
+the same signal `filter_processed_images` already uses to decide an image needs no further work
+(`ami/ml/models/pipeline.py:71`). A capture that was processed and genuinely contained nothing
+therefore takes part in the sequence and, having no detections to match, ends the chains that
+reach it. That is the behaviour the batch pass already has, and this design does not change it.
+
+A transition also has a **maximum gap**. Once pairs form between processed captures, the interval
+between two consecutive ones is unbounded, and the cost function has no elapsed-time term, so a
+different insect settling in the same spot much later would score like a stationary one
+(`docs/claude/reference/occurrence-tracking.md`, the sequence-defect section). `TrackingConfig`
+gains a configurable maximum gap in seconds. A consecutive pair further apart than that is still
+recorded as evaluated (its successor marker is written, as for any transition) but no links are
+proposed across it, so chains end at the gap and a re-run does not revisit it. Tests must cover a
+capture inserted inside a gap, which splits it into two transitions that may each fall under the
+limit, and a re-run over a session whose gaps have not changed, which must write nothing.
+
+### The marker is a recorded successor on the capture
+
+Each capture records the capture it was last evaluated *forward* against:
+
+```python
+# ami/main/models.py, on SourceImage
+tracking_successor = models.ForeignKey("self", null=True, blank=True, db_index=False,
+                                       on_delete=models.SET_NULL,
+                                       related_name="tracking_predecessors")
+tracking_evaluated_at = models.DateTimeField(null=True, blank=True)
+```
+
+A transition is **outstanding** when a capture's recorded successor is not the capture that
+actually follows it in the processed sequence. Writing the rule out:
+
+| Recorded successor | Actual successor | Outstanding? | Meaning |
+|---|---|---|---|
+| `NULL` | capture B | yes | never evaluated |
+| capture B | capture B | no | already evaluated, nothing to do |
+| capture B | capture C | yes | a capture arrived in between; the old pair is superseded |
+| capture B | `NULL` | yes | the successor was deleted or left the session |
+| `NULL` | `NULL` | no | last capture in the session; there is no forward transition |
+
+Everything the design needs follows from this one comparison. Running the pass twice with nothing
+changed finds no outstanding transitions and performs no writes. A capture arriving in the middle
+of an evaluated pair makes exactly two transitions outstanding and retires one. A capture being
+deleted makes its predecessor outstanding. Re-grouping a deployment's captures into different
+sessions (`group_images_into_events`, which is now operator-configurable) changes which captures
+are adjacent, and the boundary captures become outstanding without anything having to know that
+regrouping happened.
+
+The marker is deliberately not derived from `Detection.next_detection`. A transition that was
+evaluated and produced no links is indistinguishable from a transition never evaluated if links
+are the only record, so a link-derived marker would re-do the expensive matching for every
+transition that legitimately matched nothing — which, given the cost threshold, is likely to be
+most of them.
+
+There is a second, push-based half to the marker. When results are saved for a capture, that
+capture's detections change, so any transition touching it is stale even if adjacency did not
+move. `save_results` therefore clears `tracking_successor` on the capture it just processed and on
+the processed capture immediately before it in the session. This is what makes re-processing a
+capture with a different pipeline safe, and it is a two-row `UPDATE` found through the existing
+`(event, timestamp)` index.
+
+### Finding the outstanding transitions
+
+```python
+processed = Exists(Detection.objects.filter(source_image_id=OuterRef("pk")))
+rows = (SourceImage.objects
+        .filter(event_id=event_id).filter(processed)
+        .order_by("timestamp", "pk")
+        .values_list("pk", "tracking_successor_id"))
+```
+
+The successor of each row is the next row, computed in Python over a list of at most a few
+thousand tuples. Measured with `EXPLAIN (ANALYZE, BUFFERS)` against the local database, expressed
+in SQL with a `lead()` window function so the whole comparison happens in the database:
+
+- Session with 4,497 captures, 750 processed: **34 ms cold, 6.5 ms warm.**
+- Session with 23,362 captures, 65 processed: **291 ms cold, 18 ms warm** (three consecutive runs
+  at 18.19 / 18.20 / 18.28 ms).
+
+The plan is a bitmap index scan on the existing `main_source_event_i_ab7d5d_idx` over `event_id`,
+feeding a nested-loop semi-join whose inner side is an index-only scan on
+`main_detection_source_image_id_883797a1`. The cost is therefore bounded by the session's *total*
+capture count, because the semi-join probes once per capture — not by the processed count. That is
+the honest characterisation, and it is why the larger session is slower despite having fewer
+processed captures. If it ever becomes hot, the lever is a denormalised processed flag on
+`SourceImage`, which would make the scan bounded by the processed count instead. It is not worth
+paying for now.
+
+What this query deliberately avoids is the expensive part. Loading a detection's feature embedding
+is one query returning a 2,048-dimension `pgvector` column measured at 3,279 bytes per row, and
+`get_feature_vector` issues one such query per detection
+(`ami/ml/post_processing/tracking_task.py:175`). Processed captures in the largest session average
+14.8 detections each (p95 23, max 31, measured), so a single transition costs roughly 30 embedding
+queries and 100 KB of vector data, and roughly 225 cost computations. Those numbers are measured;
+the resulting estimate that a full batch pass over a 750-capture session issues on the order of
+22,000 embedding queries is inferred from reading the code, not profiled. Incremental evaluation
+replaces that with two transitions per newly arrived capture.
+
+### The pass
+
+For one session, inside a per-session lock and one transaction:
+
+1. Build the processed sequence and derive the outstanding transitions.
+2. If there are none, return. This is the idempotent path and it does no writes.
+3. Determine the frozen detections: those belonging to an occurrence with `grouping_verified_at`
+   set. They are excluded from matching and from severing.
+4. For each outstanding transition `(A, B)` in timestamp order:
+   a. Sever stale forward links out of `A` — any detection in `A` whose `next_detection` lives in
+      a capture other than `B`, unless either end is frozen.
+   b. Run the existing greedy matcher over `A` and `B`, skipping frozen detections.
+   c. Set `A.tracking_successor = B` and `A.tracking_evaluated_at = now()`.
+5. Reconcile occurrences for every detection touched, so that each maximal chain corresponds to
+   exactly one occurrence.
+6. Report counters on the job stage.
+
+### Worked example
+
+Take the user's scenario. Session `E`; captures are written `P8` for 8:00pm and so on. Detections
+are `d1…`; occurrences `O1…`. Every detection starts in an occurrence of its own, because
+`create_and_update_occurrences_for_detections` creates one per detection at result-saving time
+(`ami/ml/models/pipeline.py:908`).
+
+**Step 0 — captures at 8:00pm and 9:00pm are processed.**
+`P8` gets `d1, d2`; `P9` gets `d3, d4`. Occurrences `O1={d1}`, `O2={d2}`, `O3={d3}`, `O4={d4}`.
+No capture has a recorded successor.
+
+**Step 1 — first pass.**
+Processed sequence is `[P8, P9]`. `P8` has no recorded successor but its actual successor is `P9`,
+so that transition is outstanding. `P9` has neither a recorded nor an actual successor, so it is
+not. One transition to evaluate.
+
+Say the matcher accepts `d1↔d3` and rejects everything else. Links: `d1.next_detection = d3`.
+Marker: `P8.tracking_successor = P9`.
+
+Reconciling, the maximal chains are `[d1, d3]`, `[d2]` and `[d4]`. The first spans two
+occurrences, `O1` and `O3`, so they merge into `O1`. State afterwards:
+
+| | Detections | Links | Occurrences |
+|---|---|---|---|
+| after step 1 | d1 d2 d3 d4 | d1→d3 | O1={d1,d3}, O2={d2}, O4={d4} |
+
+**Step 2 — run it again immediately.**
+`P8.tracking_successor` is `P9`, which is still its actual successor. `P9` still has none. Zero
+outstanding transitions, zero writes, nothing loaded. This is the property the whole design
+exists for.
+
+**Step 3 — captures at 8:10pm and 8:20pm arrive and are processed.**
+`P810` gets `d5`; `P820` gets `d6, d7`, each in a fresh occurrence. Saving those results clears
+`tracking_successor` on `P810`, on `P820`, and on the processed capture preceding each — which
+includes `P8`. Even without that push, `P8`'s recorded successor `P9` no longer matches its actual
+successor `P810`, so the mismatch alone would have caught it.
+
+Processed sequence is now `[P8, P810, P820, P9]`, and three transitions are outstanding:
+`(P8, P810)`, `(P810, P820)`, `(P820, P9)`. The pair `(P8, P9)` is not re-evaluated and not marked
+stale — it has simply left the sequence, because `P9` is no longer what follows `P8`.
+
+Evaluating in order:
+
+- `(P8, P810)`: first sever stale links out of `P8` — `d1.next_detection` is `d3`, which is in
+  `P9`, not `P810`, so it is cleared. Then match: `d1↔d5` accepted, giving `d1→d5`.
+- `(P810, P820)`: `d5↔d6` accepted, giving `d5→d6`.
+- `(P820, P9)`: `d6↔d3` accepted, giving `d6→d3`. `d7` matches nothing.
+
+Markers become `P8→P810`, `P810→P820`, `P820→P9`. Reconciling, the maximal chain is
+`[d1, d5, d6, d3]`, spanning `O1` (which holds both `d1` and `d3`), `O5` and `O6`. They merge into
+`O1` — identifications on `O5` and `O6` are reassigned to `O1` before the emptied occurrences are
+deleted.
+
+| | Detections | Links | Occurrences |
+|---|---|---|---|
+| after step 3 | d1 d2 d3 d4 d5 d6 d7 | d1→d5→d6→d3 | O1={d1,d5,d6,d3}, O2={d2}, O4={d4}, O7={d7} |
+
+**Step 3, the branch that forces a split.** Suppose instead that `(P820, P9)` accepts nothing. The
+maximal chain is `[d1, d5, d6]`, but `d3` is still a member of `O1` from step 1, and no link
+connects it to the rest. Reconciliation must move `d3` out to an occurrence of its own. A
+merge-only reconciler — which is what `assign_occurrences_from_detection_chains` is today — would
+leave `O1={d1,d5,d6,d3}` and silently assert that a detection at 9:00pm belongs to a track that
+ends at 8:20pm.
+
+| | Detections | Links | Occurrences |
+|---|---|---|---|
+| after step 3, no match at the end | d1 … d7 | d1→d5→d6 | O1={d1,d5,d6}, O8={d3}, O2, O4, O7 |
+
+**Step 3, the branch where a person got there first.** Suppose that between step 1 and step 3
+someone verified `O1={d1,d3}` as correctly grouped. Then `d1` and `d3` are frozen: `d1` is not
+offered to the matcher as a source, `d3` is not offered as a target, and the stale `d1→d3` link is
+not severed. The three transitions are still evaluated for the remaining detections, and the
+markers are still set, so the session does not stay permanently outstanding. `O1` is untouched, and
+the pass reports that a verified occurrence in this session predates captures that have since
+arrived, so a person can decide whether to re-open it. The system does not overwrite the answer a
+person gave; it tells them the question changed.
+
+## The seven hard parts
+
+### 1. Adjacency is a moving target
+
+**The mechanism.** A superseded transition is never "invalidated" as such — it stops existing,
+because the sequence is derived rather than stored. The recorded successor of the capture before
+the insertion point no longer matches, which makes exactly one new transition outstanding on each
+side of the arrival.
+
+What must be broken is the *detection-level* link that crossed the now-superseded gap, and here
+the existing matcher already handles two of the three cases. `pair_detections` detaches any
+existing inbound link to a detection it is about to claim
+(`ami/ml/post_processing/tracking_task.py:332`), and it overwrites the source detection's
+`next_detection` when it makes a new match. So if `d1` matches something in the newly inserted
+capture, the stale link is overwritten; and if something in the inserted capture matches `d3`,
+`d3`'s stale inbound link is detached. The gap is the third case: **`d1` matches nothing in the
+inserted capture and nothing in the inserted capture matches `d3`.** The link `d1→d3` then
+survives, skipping a capture, and nothing will ever look at it again, because the transition it
+belonged to is no longer in the sequence.
+
+The rule is therefore: before evaluating an outstanding transition `(A, B)`, clear every forward
+link out of `A`'s detections that does not land in `B`. This is safe to state as an unconditional
+rule because a link out of `A` that lands anywhere but `A`'s current successor is by construction
+a link across a gap that was closed.
+
+**The alternative I rejected.** Keep the skip link, on the argument that it bridges a frame where
+the insect was occluded or the detector missed it, and that bridging is better tracking. I rejected
+it because the cost that justified the link described a transition that no longer exists — the two
+detections are now two frames apart, and the geometry terms in the cost function are the ones most
+sensitive to elapsed time. Keeping it would also mean the link's correctness depends on the order
+captures happened to be uploaded, which is not a property anyone can reason about. Gap-tolerant
+matching is a real and probably desirable feature — match each capture against the next *k*
+processed captures rather than only the next one — but it should be a deliberate, uniformly applied
+policy, not a side effect of arrival order.
+
+**One case where the rule must yield.** If either end of the stale link is frozen by a verified
+occurrence, the link is left alone; see hard part 4.
+
+### 2. Bookkeeping without a new table
+
+**The mechanism.** Two nullable columns on `SourceImage`, as above. No new model. `SourceImage` is
+already the natural home: adjacency is a property of captures, the sequence query reads that table
+anyway, and the model already carries derived fields of this kind such as `detections_count`.
+
+`Detection.next_detection` alone is not sufficient, for the reason the brief anticipates. It is
+worth being concrete about the cost of getting this wrong: with the current threshold most
+transitions are expected to produce no links at all, so a link-derived marker would re-run the
+expensive embedding fetch and matching for nearly every transition on every pass, and the
+"idempotent" claim would be false in the only sense that matters.
+
+**Migration.** `main_sourceimage` holds 14.8 million rows in 18 GB in the local copy (measured), so
+the shape of the migration matters. Both columns are nullable with no default, which PostgreSQL 11
+and later add as a catalogue-only change with no table rewrite. The one thing to avoid is the index
+Django creates for a `ForeignKey` by default, which would build over the whole table under an
+`ACCESS EXCLUSIVE`-adjacent lock. It is not needed: the only reverse question the design asks is
+"which capture precedes this one", and that is answered by timestamp order through the existing
+`(event, timestamp)` index rather than by following the marker backwards. Hence `db_index=False`.
+
+```python
+# ami/main/migrations/0100_sourceimage_tracking_markers.py
+class Migration(migrations.Migration):
+    dependencies = [("main", "0099_occurrence_grouping_verification")]
+    operations = [
+        migrations.AddField(
+            model_name="sourceimage",
+            name="tracking_successor",
+            field=models.ForeignKey(
+                "self", null=True, blank=True, db_index=False,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="tracking_predecessors",
+            ),
+        ),
+        migrations.AddField(
+            model_name="sourceimage",
+            name="tracking_evaluated_at",
+            field=models.DateTimeField(null=True, blank=True),
+        ),
+    ]
+```
+
+`on_delete=SET_NULL` is load-bearing rather than incidental: deleting a capture nulls the marker on
+its predecessor, which makes that predecessor outstanding, which is exactly the re-evaluation the
+deletion should trigger.
+
+**The alternative I rejected.** A `TrackedTransition` table with `(from_capture, to_capture,
+evaluated_at, links_created, config)` and a uniqueness constraint on the pair. It is more
+expressive — it can record how a transition was evaluated, not just that it was — but it holds
+roughly one row per processed capture, which on a table already at 14.8 million captures is a
+second large table to write, index, vacuum and reason about, in exchange for information only a
+diagnostic would read. The two columns carry the whole decision.
+
+**A related knob I also rejected.** Storing a fingerprint of the tracking configuration alongside
+the marker, so that changing `cost_threshold` makes every transition outstanding again. It is
+tempting and it is arguably correct, but it means a routine change to a project default silently
+re-tracks every session, including re-deciding groupings a person has been looking at. The operator
+job instead gets an explicit "re-evaluate from scratch" option that clears the markers for a chosen
+scope, so re-tracking after a configuration change is a decision somebody makes rather than a
+consequence they discover.
+
+### 3. Merging occurrences must not destroy identifications
+
+**The mechanism.** This one is already solved in the working tree by a parallel change, and the
+right answer is to use it rather than to write a second one. `ami/main/models_future/tracks.py`
+now carries `_absorb(target, sources)`, which reassigns `Identification.occurrence` to the survivor
+*before* deleting the emptied occurrences, precisely because `Identification.occurrence` cascades.
+`merge_occurrences(target, sources)` wraps it with a same-session check. The reconciler calls
+`merge_occurrences` and never issues `Occurrence.objects.delete()` of its own.
+
+The current batch reconciler does the opposite: it deletes sibling occurrences directly
+(`ami/ml/post_processing/tracking_task.py:256`) with a comment explaining that the fresh-event
+guard makes this safe. Removing the guard removes that safety, so this call site has to change in
+the same commit that removes `require_fresh_event`. These two edits are a pair; splitting them
+across commits leaves a window in which the code silently destroys human work.
+
+**Choosing the survivor.** Among the occurrences a chain spans, prefer the one carrying
+non-withdrawn identifications; break ties on the earliest detection timestamp and then on the
+lowest primary key, so the choice is deterministic and a re-run picks the same survivor.
+
+**When not to merge at all.** If two or more of the occurrences in a chain carry non-withdrawn
+identifications, merging them asserts that two people who each labelled a distinct animal were
+labelling one animal. The pass refuses: it cuts the chain link at the boundary between them, counts
+the refusal, and logs it. Because the transition's marker is set and the matcher is deterministic,
+the cut is stable — a later pass will not re-create it unless a capture arrives in that gap, in
+which case it re-evaluates and re-cuts, reaching the same state. **The alternative I rejected** was
+to compare the identifications' taxa and merge when they agree. That is better behaviour in the
+common case, but it needs a definition of agreement across ranks — a genus-level identification and
+a species-level one below it do not conflict — and getting that wrong destroys exactly the data
+this rule exists to protect. Refusing whenever two identified occurrences would combine is the
+conservative reading, and it matches the bias `tracks.py` already states in its module docstring:
+leave one animal as two occurrences rather than merge two animals into one.
+
+### 4. Human edits must survive
+
+**The mechanism.** Two records, both of which now exist in the working tree.
+
+The first is the invariant the human track operations already enforce: *a chain link never crosses
+an occurrence boundary*. `_cut_links_leaving` clears both outbound and inbound links that would
+escape an occurrence after any operation that moves detections. This is what makes a human split
+durable against a merge-only reconciler — the reconciler walks chains, and after a split there is
+no chain connecting the two halves, so nothing invites it to fold them back together.
+
+The second is `Occurrence.grouping_verified_at` / `grouping_verified_by`, set only by the explicit
+`verify_grouping` call and cleared by any operation that changes an occurrence's detection set.
+This is the stronger record: it means a person looked at this exact set of detections and confirmed
+it. The tracking pass treats a verified occurrence as frozen — its detections are excluded from
+matching in both directions, its links are not severed, and it is never a merge source or target.
+
+Freezing at the occurrence level rather than the session level is the important change from the
+current design. `skip_if_human_identifications` today refuses a whole session as soon as one
+occurrence in it carries an identification (`ami/ml/post_processing/tracking_task.py:522`), which
+in a session with hundreds of occurrences means one person's single click permanently stops
+tracking for everything else in that night. Per-occurrence freezing keeps the protection and drops
+the collateral damage.
+
+**A verified occurrence in a session that later gains captures is a reported condition, not a
+silent one.** The pass counts these and names them in the job stage metrics, so the natural
+follow-up — a review queue of occurrences whose evidence changed after they were confirmed — has
+the data it needs. Given that the stated priority is building a human-verified test set, an
+occurrence whose ground truth may have gone stale is exactly the kind of thing that should be
+surfaced rather than either overwritten or quietly left.
+
+**The alternative I rejected.** A per-detection `curated_at` timestamp meaning "a person edited
+this detection's track membership", checked by the matcher. It is a single column and it is
+finer-grained. I rejected it because it records the wrong thing: it captures that an edit happened,
+not what the person asserted. The occurrence-level verification says "this set is right", which is
+both the thing tracking must not contradict and the label the tracking methods will be scored
+against. Detection-level pinning would also freeze detections out of all future tracking forever,
+including in sessions where the person's edit had nothing to do with the transition being
+evaluated.
+
+### 5. Concurrency
+
+**The mechanism.** Three layers, in increasing narrowness.
+
+*Session-level exclusion, tracking against tracking.* Reuse the pattern already in this codebase:
+`_regroup_lock` at `ami/main/models.py:1476` is a token-released, TTL-capped cache lock keyed by
+deployment, whose caller short-circuits when it is already held. A `_tracking_lock(event_id)` in the
+same shape gives the same semantics per session. The short-circuit is safe here in a way it usually
+is not, and this is the design's best property: **because outstanding-ness is derived state rather
+than a queue, work that is skipped is never lost, only deferred.** A pass that cannot get the lock
+returns without doing anything, and the transitions it did not evaluate are still outstanding for
+whoever runs next.
+
+*Result-arrival debouncing.* Several captures from the same session finish in parallel workers, and
+each would otherwise enqueue a pass. `save_results` enqueues `track_event_incrementally` with a
+short countdown, guarded by a `cache.add` dedup key on the session with a TTL matching the
+countdown — the same idiom the job heartbeat endpoints use (`ami/jobs/views.py:79`). Many arrivals
+collapse into one pass, which is also what makes the pass efficient: it sees all the new captures
+at once and evaluates each transition once.
+
+*Row-level exclusion, tracking against people.* The cache lock does not protect against a person
+calling `split_track` while a pass is running, and it cannot, because a cache lock is not
+transactional and a hard worker death leaves it held until the TTL. `Detection.next_detection` is
+`UNIQUE`, so two writers assigning the same target raise `IntegrityError`. The prescription is that
+both sides take `select_for_update()` on the detections they are about to modify, ordered by
+primary key so two writers cannot deadlock against each other. For the tracking pass that is the
+detections of the two captures in the transition, on the order of thirty rows. For the human
+operations it is the occurrence's detections, which they already materialise in
+`_ordered_detections`. This is a small addition to `tracks.py` and it should land with this work,
+because today those operations take no row locks at all.
+
+**Retry semantics.** A skipped session needs no retry: the next trigger or the periodic sweep picks
+it up, and correctness does not depend on when. A genuine `IntegrityError` on `next_detection` means
+a writer outside the lock got there first; retry the session once after a short backoff, and on a
+second failure fail the job with the reason rather than retrying indefinitely, because a persistent
+conflict means an assumption is wrong and a loop would hide it. The per-session transaction means a
+failure rolls back that session and leaves its markers unset, so the work is retried in full and
+never half-recorded.
+
+**The alternative I rejected.** A PostgreSQL advisory transaction lock, `pg_try_advisory_xact_lock`,
+keyed on the session. It is strictly better than a cache lock — it is transactional, it releases on
+rollback, and it cannot be orphaned by a killed worker. I still recommend the cache lock, because
+the codebase already has one implementation of exactly this pattern with its failure modes
+documented in a docstring, and having one locking idiom that everybody recognises is worth more here
+than the correctness margin. If the advisory lock is preferred, it should replace `_regroup_lock`
+too, as a separate change.
+
+### 6. Cost and scale
+
+Covered in "Finding the outstanding transitions" above, but to answer the question directly: the
+query that finds outstanding work is a single indexed scan of one session's captures with a
+semi-join against detections, measured at 6.5 ms warm and 34 ms cold on the session with the most
+processed captures, and 18 ms warm and 291 ms cold on the session with the most captures. It is
+bounded by the session's total capture count. I have not verified any claim beyond these two
+sessions, and I have not measured the pass end to end, because the local database holds only 324
+classifications with feature embeddings — far too few to time a realistic matching run.
+
+The part that matters is what the pass *does not* do. It never loads a feature embedding for a
+transition it is not evaluating, and after the first pass over a session the number of transitions
+it evaluates is two per newly arrived capture rather than one per capture in the session. On the
+750-capture session that is the difference between roughly 22,000 embedding queries and roughly 60
+— the first figure inferred from reading `get_feature_vector` and the per-capture detection counts,
+not profiled.
+
+One bound worth stating explicitly because it is not obvious: the reconciliation step walks maximal
+chains, and a chain can extend outside the window of captures the pass evaluated. The reconciler is
+therefore a fixpoint over a work-set of detections rather than a loop over a fixed list — seed it
+with the detections of the evaluated transitions plus the detections of every occurrence those
+touch, and process chains until the set is empty. Chain length is bounded by how long an insect
+stays on the sheet, which at one processed capture per minute could be hundreds of frames. I have
+not measured chain lengths, because no production data has been tracked yet; see the last section.
+
+### 7. The trigger
+
+**The recommendation.** Fire from the tail of `save_results`, into a debounced per-session Celery
+task, gated by a project-level setting that is off by default. Keep the operator-triggered
+post-processing job for explicit and configuration-changing runs. Add a periodic sweep as a
+backstop, restricted to sessions whose captures changed in the last day.
+
+`save_results` is the right place because it is the only point that knows a capture has just become
+processed, and both the synchronous and asynchronous result paths funnel through it
+(`ami/ml/models/pipeline.py:1016`). It is also where the per-detection occurrences are created, so
+tracking runs immediately after the state it consumes is written.
+
+**Why not a signal.** A `post_save` signal on `Detection` would fire once per detection — thousands
+per batch — and, decisively, it would not fire at all: `create_and_update_occurrences_for_detections`
+uses `bulk_create` and `bulk_update` (`ami/ml/models/pipeline.py:946`), and neither sends model
+signals. A signal-based trigger would silently never run.
+
+**Why not the periodic sweep alone.** Finding outstanding transitions across all sessions means the
+sequence query without an `event_id` filter, which is a scan of the whole capture table rather than
+one session's slice, and it puts minutes of latency between a capture being processed and its
+occurrence appearing correctly grouped in the interface. As a backstop scoped to recently-changed
+sessions it is cheap and worth having, because it recovers sessions whose results landed while
+tracking was disabled, failing, or losing the lock.
+
+**Why gate it off by default.** Tracking changes occurrence grouping, which changes occurrence
+counts, taxa counts and what the gallery shows. The cost threshold is documented in the code as
+calibrated against synthetic features in tests, and the measurement above suggests it may not link
+anything at all on real sampled sessions. Turning it on per project, after somebody has looked at
+what it does to that project's sessions, is the difference between a feature and an incident. The
+tradeoff is real and worth naming: a default-off switch means most projects get no benefit until
+somebody makes a decision, and the automatic path will be less exercised, so bugs in it will surface
+later. I still recommend it, and I would revisit the default once there is a verified test set to
+score against.
+
+## What changes in the code
+
+| File | Shape of the change |
+|---|---|
+| `ami/main/models.py` | Two fields on `SourceImage`: `tracking_successor` (self-FK, `db_index=False`, `SET_NULL`) and `tracking_evaluated_at`. |
+| `ami/main/migrations/0100_sourceimage_tracking_markers.py` | New migration, as above. Two `AddField`s, no rewrite, no index build. |
+| `ami/ml/post_processing/tracking_task.py` | The substantial rewrite. `assign_occurrences_by_tracking_images` is replaced by a pass over outstanding transitions. `event_is_fresh` and `event_fully_processed` are deleted. `pair_detections` gains a `skip_detection_ids` parameter; its body is otherwise unchanged. The caller gains the stale-link severing step. `TrackingConfig` loses `require_fresh_event`, `require_completely_processed_session` and `skip_if_human_identifications` as *behaviour* — see the note below — and gains `reset_scope: bool = False`. |
+| `ami/ml/post_processing/tracking_reconcile.py` | New. The chain-to-occurrence reconciler: fixpoint over a detection work-set, merge and split, delegating all occurrence deletion to `merge_occurrences`. |
+| `ami/main/models_future/tracks.py` | Promote `_absorb`, `_cut_links_leaving` and `_clear_verification` to public names so the reconciler can use them. Add `select_for_update()` on the detections each operation modifies, ordered by primary key. |
+| `ami/ml/models/pipeline.py` | At the tail of `save_results`: clear the tracking markers for the processed captures and their predecessors, then enqueue the debounced pass per affected session. |
+| `ami/ml/tasks.py` | New `track_event_incrementally(event_id)` shared task holding `_tracking_lock`. |
+| `ami/main/models.py` (lock helper) | `_tracking_lock(event_id)`, modelled on `_regroup_lock` at line 1476. |
+| `ami/main/models_future/projects.py` | A boolean on `ProjectSettingsMixin` enabling automatic tracking, defaulting to off — the same place `session_time_gap_seconds` and the default filters live. Adds a second small migration. |
+| `config/settings/base.py` | Beat entry for the recently-changed-sessions sweep. |
+| `ami/ml/post_processing/admin/tracking_form.py` | Drop the "only track untracked sessions" and "skip sessions with human identifications" knobs; add "re-evaluate from scratch". |
+| `ami/ml/post_processing/tests/test_tracking_task.py` | New cases; see below. |
+
+**A note on removing config fields.** `TrackingConfig` sets `extra = "forbid"`
+(`ami/ml/post_processing/tracking_task.py:61`), and existing `Job.params` rows carry the removed
+field names. Deleting the fields outright makes those jobs fail to re-run with a validation error.
+Keep the three fields declared, ignored, and marked deprecated in their comment, and remove them in
+a later release once no live job params reference them.
+
+**Tests worth writing, in the order they matter.** Running the pass twice writes nothing the second
+time (the core claim). A capture arriving between two evaluated captures produces exactly two
+outstanding transitions and severs the skip link. A chain that stops mid-way splits the trailing
+detection out of the shared occurrence — the branch a merge-only reconciler gets wrong. A merge
+moves identifications to the survivor and the survivor still has them after the source is deleted.
+A verified occurrence is untouched by a pass over a session that gained captures, and the pass
+reports it. Two identified occurrences are not merged. A second pass holding the lock returns
+without writing, and the transitions it skipped are still outstanding afterwards.
+
+## What stays the same
+
+The cost function survives untouched: `total_cost`, `cosine_similarity`, `iou`, `box_ratio`,
+`distance_ratio` and `image_diagonal` are unchanged, and so is the meaning of `cost_threshold`.
+
+The greedy claim-set matching survives. `pair_detections` keeps its structure — build candidates
+below threshold, sort by `(cost, det.pk, nxt.pk)` for determinism, then claim greedily with one
+partner per detection on each side. It gains one parameter, a set of detection ids to skip, and its
+existing inbound-detach step turns out to be exactly right for the insertion case. The determinism
+of the tie-break is more load-bearing in this design than in the batch one: it is what makes
+re-evaluating a transition produce the same answer, which is what makes a refused merge stable
+rather than flapping.
+
+The chain-walk primitive survives as a primitive — follow `next_detection` forward, follow
+`previous_detection` back to find the head. What does not survive is the reconciler built around it.
+`assign_occurrences_from_detection_chains` merges only, deletes occurrences directly, and takes a
+list of source images as its scope. All three have to change: it must split as well as merge, it
+must delegate deletion to `merge_occurrences` so identifications move first, and its scope must be a
+work-set of detections that can follow chains beyond the captures the pass evaluated. It is honest
+to call this a rewrite rather than an adaptation.
+
+`get_unique_feature_algorithm_for_event`, `get_feature_vector`, the `TrackingTask` shell, the
+post-processing job framework, the admin action machinery and both entry points (capture set and
+Events changelist) are unchanged.
+
+## What I am unsure about
+
+**Whether the cost threshold links anything at all on real sessions, which would make this design
+correct and useless at the same time.** The gap between adjacent processed captures is 45 to 600
+seconds (measured), and `total_cost` sums `(1 - IoU)` among its terms. Two boxes that do not overlap
+contribute 1.0 from that term alone, which already exceeds the default threshold of 0.2, so on this
+data the matcher would link only insects that barely moved in a minute. This is inferred from
+reading the cost function, not measured, but it is a strong enough inference that I would settle it
+before building anything. *The experiment:* take one session with embeddings, compute the full cost
+matrix for every adjacent processed pair, and plot the distribution of the minimum cost per
+detection against the time gap. If the mass sits above 0.2, the threshold — or the cost function's
+weighting of geometry against appearance — needs work before incremental evaluation is worth having.
+
+**Whether severing the skip link improves or degrades grouping.** I argued for severing on
+principle, but it is an empirical question and the principle could be wrong. *The experiment:* once
+there is a set of `grouping_verified` occurrences, run both policies over the same sessions with
+captures deliberately withheld and then added, and score each against the verified groupings. This
+is the first thing the verified test set should be spent on.
+
+**Whether the reconciler's chain walk is bounded in practice.** Chain length is bounded by how long
+an insect stays in frame, which nobody has measured because no production data has been tracked. If
+chains routinely run to hundreds of detections, walking one per pass per touched detection is more
+expensive than I have assumed. *The experiment:* after the first real tracking run, record the
+distribution of detections per occurrence, and if the tail is long, cap the walk and reconcile in
+batches keyed on occurrence rather than on chain.
+
+**Whether per-session locking is granular enough.** A session is a night; a pass over one that has
+just gained a thousand captures could hold the lock for minutes while other passes for the same
+session are dropped. Dropping is safe, but it could mean a busy session's tracking lags behind its
+results indefinitely. *The experiment:* instrument the pass with the number of transitions evaluated
+and the wall time, and watch whether the dedup key ever expires with work still outstanding. If it
+does, the fix is to evaluate outstanding transitions in bounded chunks and re-enqueue, which the
+marker makes safe to do at any point.
+
+**Whether automatic triggering should be gated per project or per deployment.** I recommended per
+project because that is where `ProjectSettingsMixin` already collects settings of this kind, but sampling rates are a
+property of how a station is operated, and the measurement above shows they vary between sessions
+within what may be the same project. *The experiment:* check whether processed-capture gaps cluster
+by project or by deployment across the local database; if by deployment, the setting belongs there.
diff --git a/docs/claude/reference/occurrence-tracking.md b/docs/claude/reference/occurrence-tracking.md
new file mode 100644
index 000000000..cf5220976
--- /dev/null
+++ b/docs/claude/reference/occurrence-tracking.md
@@ -0,0 +1,340 @@
+# Occurrence tracking
+
+How Antenna groups repeated detections of the same insect into one occurrence, what
+the implementation actually does, and the traps that are invisible in a diff.
+
+Feature branch: `claude/revive-tracking-feature-OyMO3` (PR #1272). Original work by
+@mohamedelabbas1996 in #863.
+
+## Vocabulary
+
+Say **occurrence**, not "track". Tracking does not introduce a data model — `Occurrence`
+has always held many `Detection` rows. Tracking is a *method of populating* that
+relationship, using feature vectors and a per-detection link to the next frame. A
+"track" in conversation means "an occurrence whose detections span several captures".
+
+## Why it exists
+
+Each detection gets its own occurrence when a pipeline runs, so an insect that sits
+still for 37 captures contributes 37 to the abundance count for its species that night.
+Tracking folds those back into one occurrence with a duration. The stated project
+preference is that **more splits are better than incorrect lumping** — leaving one
+animal as two occurrences costs a little accuracy, whereas merging two animals destroys
+a record nothing downstream recovers. Set thresholds to err low.
+
+## Data model
+
+| Field | Where | Purpose |
+|---|---|---|
+| `Detection.next_detection` | `ami/main/models.py` | `OneToOneField("self", related_name="previous_detection", null=True)`. The chain link. UNIQUE, so two detections can never claim the same successor. |
+| `Classification.features_2048` | `ami/main/models.py` | `pgvector.django.VectorField(dimensions=2048, null=True)`. The classifier's penultimate-layer embedding. |
+| `Occurrence.detections` | reverse FK | Already existed. Tracking populates it; nothing about it is new. |
+
+Migrations `0096_add_pgvector_extension`, `0097_classification_features_2048`,
+`0098_detection_next_detection`.
+
+The embedding is produced by the **classification model**, not a dedicated similarity
+model — whatever classifier ran is the vector producer. A model trained for similarity
+would be a better instrument, especially for re-identifying an individual across a
+ten-minute sampling gap rather than across seconds of motion; nothing in the design
+blocks swapping it, because the cost function only requires that one model produced all
+the vectors being compared.
+
+## How matching works
+
+`ami/ml/post_processing/tracking_task.py`
+
+Cost between two detections in consecutive captures, each term roughly 0 for a perfect
+match and 1 for an unrelated pair:
+
+```
+(1 - cosine(f1, f2)) + (1 - IoU) + (1 - box area ratio) + (centre distance / diagonal)
+```
+
+Candidate pairs below `cost_threshold` are sorted and claimed greedily, each detection
+at most once. Ties break on `(cost, det.pk, nxt.pk)` so re-runs are deterministic.
+`assign_occurrences_from_detection_chains()` then walks `next_detection` chains and
+folds each into the chain's **first existing occurrence** (merge-into-first), deleting
+now-empty siblings.
+
+`TrackingConfig` (the pydantic `config_schema`) knobs:
+
+| Key | Default | Meaning |
+|---|---|---|
+| `source_image_collection_id` / `event_ids` | — | Scope. Exactly one is required. |
+| `cost_threshold` | 0.2 | Link below this. See "choosing it" below. |
+| `require_features` | True | False drops the appearance term and matches on geometry alone. |
+| `require_fresh_event` | True | Skip sessions whose occurrences already span >1 detection. |
+| `skip_if_human_identifications` | True | Protect reviewed sessions. |
+| `feature_extraction_algorithm_id` | None | Disambiguate when several classifiers ran. |
+| `require_completely_processed_session` | False | Off deliberately; see below. |
+
+## The trap that matters most
+
+**Tracking can only link detections in captures that are consecutive AND both
+processed.** Detection volume is irrelevant. Most ML runs are deliberately samples
+(ten-minute snapshots, every Nth frame), which leaves processed captures scattered and
+nothing adjacent to link.
+
+Run this before picking data or diagnosing an empty result:
+
+```python
+imgs = list(Event.objects.get(pk=E).captures.order_by("timestamp").values_list("id", flat=True))
+with_dets = set(Detection.objects.filter(source_image__event_id=E)
+                .values_list("source_image_id", flat=True).distinct())
+adjacent = sum(1 for i in range(len(imgs)-1) if imgs[i] in with_dets and imgs[i+1] in with_dets)
+```
+
+Measured: one session with 4,138 captures and 14,366 detections had 663 processed
+captures, none adjacent — zero linkable pairs. Another with 453 captures and 4,298
+detections had 272 adjacent pairs and tracked well. Capture *cadence* is not a proxy;
+a 4-second-interval session that was only sampled has almost nothing to link.
+
+`Event.detections_count` / `occurrences_count` are cached and go stale — count from
+`Detection.objects.filter(source_image__event_id=...)` when choosing data.
+
+This is also why `require_completely_processed_session` defaults off: "the whole session
+has been processed" is a state most real sessions never reach.
+
+## Defect: the sequence is built from all captures, not processed ones
+
+`tracking_task.py:358` is `source_images = list(event.captures.order_by("timestamp"))` —
+every capture — and the loop pairs `source_images[i]` with `[i+1]`. On a sampled session a
+processed capture's neighbours are unprocessed and hold no detections, so two processed
+captures with unprocessed ones between them are **never compared to each other**, at any
+threshold or time bound.
+
+Measured 2026-09-02 (transitions with detections on both sides):
+
+| event | captures | processed | evaluated | usable now | usable if fixed | median gap |
+|---|---|---|---|---|---|---|
+| 2610 | 4,138 | 663 | 4,137 | **0** | 662 | 60 s |
+| 349 | 17,555 | 23 | 17,554 | **0** | 22 | 1,200 s |
+| 6834 | 2,545 | 391 | 2,544 | 69 | 390 | 50 s |
+| 6719 | 453 | 294 | 452 | 272 | 293 | 60 s |
+
+Event 6719 is 65% processed and densely contiguous, so it barely shows the defect — which
+is why every demo number came from it. Do not generalise from that session.
+
+The fix is to build the sequence from processed captures only (a capture counts as
+processed when any `Detection` row references it, sentinel included — the same signal
+`filter_processed_images` uses). **Do not ship it alone.** Once pairs form between
+processed captures the interval between them is unbounded, and `total_cost` has no elapsed-time
+term, so a different insect settling in the same spot a night later scores like a
+stationary one. Pair the fix with a configurable maximum gap; the minimum is bounded by
+the data model, which has no sub-second timestamps.
+
+## Choosing `cost_threshold`
+
+Measure, do not guess. Best-match cost is bimodal. Geometry-only over one real session:
+p5 0.037, p25 0.273, median 1.170, p75 1.356 — true matches near zero, unrelated pairs
+near the sum of their terms, and a wide sparse valley between. Anywhere from ~0.4 to 1.0
+gives nearly the same links. **0.4 is a good default for geometry-only on dense
+captures.** Sampling the distribution is a short read-only script over `iou`,
+`box_ratio` and `distance_ratio` from `tracking_task.py`.
+
+## Running it
+
+Django admin → **Capture sets** or **Events** → select rows → *Run Occurrence Tracking*.
+An intermediate confirmation page renders the knobs; config is validated against
+`TrackingConfig` at submit, not later in the worker. One job per capture set; an Events
+selection is partitioned into one job per project. Stage metrics report events tracked /
+skipped, links created, occurrences merged, and every skip is logged with its reason.
+
+Built with `make_post_processing_action` (`ami/ml/post_processing/admin/actions.py`),
+the same factory as Small Size Filter and Class Masking. Form in
+`ami/ml/post_processing/admin/tracking_form.py`; the Events job builder in
+`admin/tracking_actions.py`.
+
+## Getting a session to try it on
+
+`python manage.py create_demo_project` adds one night built for tracking: 24 captures two
+minutes apart in an event of their own, ten simulated insects (six staying for a run of
+six or more frames, four appearing once), 99 detections each on its own occurrence, and a
+2048-d embedding per classification under algorithm `demo-tracking-classifier`. It needs
+no processing service. The command prints which detections belong to which simulated
+insect, and `--ground-truth-output PATH` writes that mapping as JSON so a run can be
+scored against it — `score_tracking_run()` in `ami/tests/fixtures/tracking.py` does the
+comparison.
+
+Measured on the generated frames: an insect's own consecutive detections score under 0.15
+geometry-only, unrelated pairs never below 1.2. Both a geometry-only run at
+`cost_threshold=0.4` and a default run using the embeddings recover all ten groups
+exactly. `--tracking-motion-scale` above its 0.2 default makes the session harder.
+`--no-tracking-session` skips the extra night.
+
+## Where results are visible
+
+Nothing new was needed to *see* an occurrence's detections — the existing views were
+always showing chains of length one.
+
+- **Occurrence detail** — vertical list of detection thumbnails with timestamps and a
+  *View in session* link each. Note the detail endpoint prefetches `-timestamp`
+  (**newest first**, `prefetch_detections_for_detail()` in
+  `ami/main/models_future/occurrence.py`), which is the reverse of chain order.
+- **Session detail** — click an occurrence and it stays highlighted as you step through
+  captures with the next/prev arrows.
+- **Occurrences list** — `duration` stops being zero for merged occurrences; the
+  snapshots column shows several crops. Sorting by duration descending is the fastest
+  check that a pass produced anything sensible.
+
+## The front end
+
+`ui/src/pages/occurrence-details/track/` and `ui/src/pages/session-details/capture/`.
+
+Occurrence detail carries the repair path: a per-frame menu (split, move, remove) and an
+occurrence-level bar (merge, confirm/undo, and a badge naming who confirmed and when).
+Session detail draws the rest of a selected occurrence's frames over the current capture
+as fading dashed boxes joined by the path through their centres, capped at sixteen boxes
+and toggled from view settings.
+
+Four things that are easy to get wrong here:
+
+- **The strip is newest-first but a split cuts by time.** `OccurrenceDetails` sorts frames
+  by timestamp rather than taking payload order, so display position and split semantics
+  cannot drift apart. The confirmation copy names the boundary time and the counts either
+  side.
+- **The confirmation dialogs are rendered by the page, not by the frame menu.** An edit
+  moves the clicked frame off the occurrence, so a dialog owned by that frame is unmounted
+  by the refresh before it can report its result.
+- **Controls are gated on `user_permissions` from the detail payload** — `delete` for
+  restructuring, `delete` or `update` for confirming, mirroring
+  `Occurrence.check_custom_permission`.
+- **A ghost box is measured in its own capture.** `bboxToPercentStyle` takes the
+  dimensions explicitly; scaling a neighbouring frame's box by the displayed capture's
+  dimensions puts it in the wrong place.
+
+## Editing and confirming a grouping
+
+`ami/main/models_future/tracks.py`, exposed as six actions on `OccurrenceViewSet`. All
+operate on the occurrence's detections in timestamp order, so they behave sensibly on
+occurrences that were never tracked.
+
+| Endpoint (`POST /api/v2/occurrences/{id}/…`) | Body | Effect |
+|---|---|---|
+| `split-track/` | `{"detection_id": N}` | That detection and every **later** one move to a new occurrence |
+| `remove-detection/` | `{"detection_id": N}` | One detection moves to an occurrence of its own |
+| `merge/` | `{"occurrence_ids": [...]}` | Those occurrences are absorbed into this one and deleted |
+| `add-detections/` | `{"detection_ids": [...]}` | Chosen detections move here from wherever they were |
+| `verify-grouping/` | — | Records that a person confirmed this set of detections |
+| `unverify-grouping/` | — | Clears that confirmation |
+
+Adding a single frame is the one-detection case of merge, since a lone detection is
+already an occurrence.
+
+### Why verification is a separate axis
+
+`Identification` records *what the animal is*. Nothing recorded *these detections are one
+animal and none are missing*, so `Occurrence.grouping_verified_at` / `grouping_verified_by`
+were added (migration `0099`). The two judgements are independent: a correctly grouped
+occurrence can carry the wrong species, and vice versa. Confirmed groupings are the ground
+truth that tracking changes get scored against — without them, evaluating a threshold
+change is spot-checking.
+
+### Two invariants every operation upholds
+
+- **A chain link never crosses an occurrence boundary within one session.** If a `next_detection` link
+  survives across a human's split, the next tracking pass walks that chain and re-merges
+  what they separated. `_cut_links_leaving()` cuts the links leaving any moved set.
+- **Any edit that changes the detection set clears verification.** A person confirmed the
+  set they were shown. `clear_grouping_verification()` clears the **loaded instances as well as
+  the rows** — clearing only via queryset `.update()` lets a later `occurrence.save()`
+  write the stale confirmation straight back. That was a real test failure, not a
+  hypothetical.
+
+Ordering hazard inside `_absorb()`: identifications are reassigned *before* source
+occurrences are deleted, because `Identification.occurrence` CASCADEs.
+
+### Permissions
+
+Restructuring (`split_track`, `remove_detection`, `merge`, `add_detections`) requires
+`Project.Permissions.DELETE_OCCURRENCES`. Confirming (`verify_grouping`,
+`unverify_grouping`) accepts **either** `CREATE_IDENTIFICATION` or `DELETE_OCCURRENCES` —
+confirming is an expert judgement rather than a restructuring, but the roles that
+restructure do not inherit identifying rights and must be able to confirm their own
+corrections. `MLDataManager` holds `DELETE_OCCURRENCES` but not `CREATE_IDENTIFICATION`,
+which is what forced the `or`.
+
+## Regrouping sessions and tracks
+
+A regroup (`_group_images_into_events_locked`, `ami/main/models.py`) can draw a session
+boundary through a tracked occurrence. Just before it realigns `Occurrence.event_id`, it
+finds occurrences whose valid detections span more than one `source_image.event_id` (one
+aggregate query, `_split_tracks_at_session_boundaries`) and splits each with
+`split_at_session_boundaries()` (`ami/main/models_future/tracks.py`). Product decisions:
+
+- One piece per session; each piece's `event` is its own detections' session. The earliest
+  piece keeps the original row and its identifications.
+- Grouping confirmation is **kept** on every piece (a manual split clears it): each piece is
+  still the whole track within its session.
+- Identifications are **copied** to each later piece via `bulk_create` (skipping
+  `Identification.save()`, which would withdraw the user's other IDs), with the original
+  `created_at` written afterwards (`auto_now_add`) and a "Copied from occurrence N…" note in
+  the comment. Determinations are recomputed with `update_occurrence_determination`.
+- The `next_detection` link between pieces is **kept** to record that they are one animal.
+  So the chain walk in `assign_occurrences_from_detection_chains` stops at a detection in
+  another session, and a detection linked from another session starts its own chain.
+  Pairing only ever links consecutive captures of one event, so it never creates such a link.
+- `event_is_fresh` finds occurrences through detections' captures, not `Occurrence.event`.
+- The regroup stage reports `Tracks split at a session boundary` (key
+  `tracks_split_at_a_session_boundary`; stage param keys use underscores). A second regroup
+  with no changes splits nothing.
+
+`_move_to_new_occurrence` gives every new occurrence (manual split, detach, regroup split)
+the session of its first detection's capture, not the original occurrence's.
+
+`_cut_links_leaving` (called by `merge_occurrences` / `add_detections`) skips links whose two ends
+are in different sessions, so editing one piece keeps the record that the animal continues.
+
+Tests: `TestRegroupSplitsTracks` in `ami/main/tests.py`.
+
+## Gotchas
+
+- **`OccurrenceViewSet` sets no `permission_classes`**, so it inherits the project-wide
+  `IsActiveStaffOrReadOnly` default from `config/settings/base.py`. A new POST `@action`
+  returns 403 for everyone non-staff and object permissions never run. Scope
+  `get_permissions()` per action.
+- **`check_custom_permission` derives the codename as `f"{action}_{model_name}"`**, so a
+  `split_track` action looks for a `split_track_occurrence` permission that does not
+  exist. Override on the model. There is **no `update_occurrence` permission**.
+- **`OccurrenceQuerySet.valid()` excludes `determination__isnull=True`.** An occurrence
+  created by a split is invisible to the API until it has a determination — real tracked
+  data always has classifications, so this mostly bites test fixtures. Give fixture
+  detections a classification and call `occurrence.save()`.
+- **`Occurrence.save()` recomputes determination** via `update_occurrence_determination`.
+  After moving detections between occurrences, save both.
+- **`Identification.occurrence` CASCADEs.** Any merge that deletes an absorbed occurrence
+  must reassign its identifications to the survivor first. Both paths now do:
+  `_absorb()` for human edits, and `assign_occurrences_from_detection_chains()` for the
+  batch pass. **Do not reintroduce the assumption that a fresh event has no
+  identifications** — the code claimed exactly that and it is false. Freshness means no
+  chains exist, which says nothing about whether anyone has reviewed the detections; an
+  untracked-but-reviewed session is ordinary. Measured on one real session: 12
+  identifications, of which a simulated run would have deleted 11, because the keeper is
+  the chain's first occurrence and an identified one survives only at roughly one in the
+  mean chain length. `skip_if_human_identifications` is a guard an operator can switch
+  off from the form, not an invariant.
+- **pgvector must be in the Postgres image AND the Python environment of both the django
+  and celeryworker images.** With `VectorField` on the model but the module missing from
+  the worker, `bulk_create` can save the row and silently drop the vector.
+- **Pull-mode workers get no config from Antenna.** `PipelineProcessingTask` has no
+  config field, so a worker reads `AMI_INCLUDE_FEATURES` from its own environment.
+  Setting `Pipeline.default_config` does not reach it.
+
+## Open work
+
+- **An edit can create an occurrence the API then hides.** A split or a removal makes a
+  new occurrence whose determination score may fall below the project's default score
+  threshold, at which point `apply_default_filters` excludes it from every list and detail
+  response — the row exists and passes `valid()`, but `GET /occurrences/<id>/` returns 404
+  and it cannot be offered back in a merge picker. Measured on a project with a 0.5
+  threshold: a detached frame scored 0.343. Some edits are therefore not reversible
+  through the interface.
+- **Sequence defect + a maximum pair gap** — see the section above; these ship together.
+- **A re-run must not overrule a confirmation.** Nothing currently stops a second tracking
+  pass from re-merging a grouping a person split and confirmed. `event_is_fresh` refuses
+  already-grouped sessions wholesale, which is a blunt substitute.
+- **Idempotent incremental tracking** — see `docs/claude/planning/idempotent-incremental-tracking.md`.
+  The unit of work becomes a pair of adjacent processed captures rather than a session,
+  so a pass is always safe to re-run and picks up only new work.
+- **A dedicated similarity model** rather than borrowing the classifier's embedding.
diff --git a/docs/claude/reference/tracking-evaluation.md b/docs/claude/reference/tracking-evaluation.md
new file mode 100644
index 000000000..e8967f80d
--- /dev/null
+++ b/docs/claude/reference/tracking-evaluation.md
@@ -0,0 +1,130 @@
+# Evaluating occurrence tracking against confirmed tracks
+
+A first, read-only method for measuring how well tracking rebuilds tracks that people have
+checked by hand. Companion to `reference/occurrence-tracking.md`.
+
+## What counts as ground truth
+
+An occurrence whose grouping a person confirmed (`Occurrence.grouping_verified_at` is set) is
+taken to be one complete and accurate track: every detection in it is the same insect, and no
+detection of that insect is missing from it.
+
+Nothing is known about detections outside confirmed tracks. A predicted link from a confirmed
+detection to an unconfirmed one might be right or wrong. So every number below is computed only
+over **D, the set of detections that belong to a confirmed track**. Predicted tracks are cut
+down to their detections in D before scoring.
+
+## What is measured
+
+All in `ami/ml/post_processing/tracking_evaluation.py::evaluate_tracks`, which returns a
+`TrackingEvaluation` dataclass (`to_dict()`, `summary_lines()`).
+
+| Field | Meaning | Read it as |
+|---|---|---|
+| `pairwise_precision` / `_recall` / `_f1` | Over every unordered pair of detections in D: predicted same-track pairs that are truly the same insect / all predicted same-track pairs; and / all true same-track pairs. | Precision drops with wrong merges; recall drops with fragmentation. Long tracks weigh more (pairs grow with length squared). |
+| `link_precision` / `_recall` / `_f1` | A link is two detections that follow each other in time within one track. A predicted link is correct when the same two detections are adjacent in the confirmed track. | Closer to what an editor fixes by hand: one wrong link is one split or merge to undo. |
+| `ground_truth_track_scores[]` | Per confirmed track, keyed by `track_id` (the confirmed occurrence id): `length`, `fragments` (how many predicted tracks it is split across), `completeness` (largest piece / length), `exactly_recovered`. | `fragments == 1` and `exactly_recovered` means nothing to fix. |
+| `predicted_track_scores[]` | Per predicted track touching D, keyed by `first_detection_id` (its earliest detection in D, a detection id, not an occurrence id): `length` in D, `ground_truth_tracks` it spans, `purity` (largest share / length). | `ground_truth_tracks > 1` is a merge of different insects. |
+| `merges`, `fragmented_tracks`, `exactly_recovered` | Counts of the above. | Headline counts for a table. |
+| `mean_completeness`, `mean_purity` | Unweighted means over tracks. | Each track counts once regardless of length. |
+| `ground_truth_tracks`, `detections`, `ground_truth_singletons`, `predicted_tracks`, `predicted_singletons` | Sizes. | Always report next to the scores: small benchmarks move a lot. |
+
+Precision values are `None` (`null`, printed `n/a`) when nothing was predicted, for example when
+no link passed the threshold. A confirmed single-detection track is a legitimate test case: a run
+that attaches something to it loses pairwise precision and purity.
+
+Link order within a track is capture time, then detection id to break ties.
+
+## How to run it
+
+### 1. Inside Antenna, re-linking the raw detections (management command)
+
+```bash
+docker compose run --rm django python manage.py evaluate_tracking --project <id> \
+    [--event <id> --event <id>] [--cost-threshold 0.2] [--require-features | --no-require-features] \
+    [--feature-extraction-algorithm <id>] [--format text|json] [--per-track]
+```
+
+- Ground truth: confirmed occurrences in the project (optionally only the listed sessions).
+- Predictions: for each session holding a confirmed track, the tracking link step is re-run over
+  every valid detection in the session as if none were linked (`propose_event_links` in
+  `ami/ml/post_processing/tracking_task.py`). The stored `next_detection` links and occurrence
+  assignment are ignored, because confirmed sessions have already been tracked and hand-corrected.
+- Sessions where tracking would not run (no embeddings with `--require-features`, several feature
+  extractors and none chosen) are listed under `skipped_events` and left out of the overall score.
+- The task's other guards (fresh-session check, skip when people identified occurrences, fully
+  processed) are not applied: they decide whether to write, not how to link.
+- Nothing is written. The command runs in `transaction.atomic()` with `set_rollback(True)`, and
+  `TestEvaluateTrackingCommand` checks detection and occurrence rows are identical afterwards.
+
+Output: per-session scores and an overall score pooled over all scored sessions. JSON has the
+keys `project_id`, `config`, `events[]` (`event_id`, `feature_extraction_algorithm_id`, `note`,
+`links_proposed`, `evaluation`), `skipped_events[]`, `overall`.
+
+### 2. Outside Antenna, from exported CSVs
+
+```bash
+python -m ami.ml.post_processing.tracking_evaluation --ground-truth gt.csv --predictions pred.csv \
+    [--format text|json] [--per-track]
+```
+
+Standard library only; run from a checkout root (the package `__init__` imports nothing, so
+Django does not need to be installed or configured). Both files use the tracks export format (one
+row per detection; columns include `occurrence_id`, `detection_id`, `timestamp`, `frame_index`,
+`grouping_verified`). Ground truth is the rows of the first file with `grouping_verified` true,
+grouped by `occurrence_id`; predictions are all rows of the second file, grouped the same way. This
+is the path for comparing a tracker that runs elsewhere: write its output in the same format.
+
+Every confirmed row needs an ISO 8601 `timestamp`, and all of them must be either timezone-aware
+or naive. A blank, unreadable or mixed file is refused with the offending `detection_id`s and exit
+code 2. The management command likewise refuses a confirmed detection whose capture has no timestamp.
+
+### 3. From Python
+
+```python
+from ami.ml.post_processing.tracking_evaluation import evaluate_tracks, tracks_from_links
+
+predictions = tracks_from_links(all_detection_ids, [(earlier_id, later_id), ...])
+result = evaluate_tracks(ground_truth={det_id: track_id}, predictions=predictions,
+                         timestamps={det_id: capture_time})
+print("\n".join(result.summary_lines()))
+```
+
+## Known limits
+
+- **Only confirmed tracks count.** Links into unconfirmed detections are neither rewarded nor
+  penalised, so a tracker that wrongly attaches unreviewed detections to a confirmed track is not
+  caught unless those detections are in another confirmed track.
+- **Confirmed tracks are probably biased toward easy ones.** People are likely to confirm short,
+  clean tracks first and leave crowded sessions for later. Not measured; worth checking how the
+  confirmed set compares with the rest of each session (length, crowding) before reading scores as
+  representative.
+- **Timestamp ties.** Detections in one capture share a timestamp; the tie-break is detection id.
+  A confirmed track should never hold two detections from one capture, so ties inside a track
+  point to a data problem rather than an ordering question.
+- **Sessions are scored whole.** The command re-links every detection in a session, including
+  unconfirmed ones, because they compete for links with the confirmed ones.
+- **No weighting by session.** The overall score pools detections, so one large session dominates.
+  Per-session scores are in the output for that reason.
+
+## Next steps (not built)
+
+- Parameter sweeps: run the command over a grid of `--cost-threshold` values, with and without
+  features, and table link F1 against threshold. A small wrapper script is enough to start.
+- Per-species breakdown: group the per-track scores by the confirmed occurrence's determination.
+  Untested idea; needs the determination added to the command's output.
+- A dry-run tracking job (#1416) that stores proposed links for review in the UI would reuse
+  `propose_event_links` rather than a second copy of the linking logic.
+- Scoring the tracker's current stored output (rather than a fresh re-link) is a different
+  question, answered by exporting the tracks CSV before and after hand-correction and comparing
+  them with the CSV mode.
+
+## Code map
+
+- `ami/ml/post_processing/tracking_evaluation.py`: `evaluate_tracks`, `tracks_from_links`,
+  `evaluate_csv_files`, `main`; no Django imports.
+- `ami/ml/post_processing/tracking_task.py`: `iter_transition_links` (read-only, shared by the task
+  and the evaluator), `propose_event_links`, `select_transition_links`, `save_links`.
+- `ami/main/management/commands/evaluate_tracking.py`: the command.
+- Tests: `ami/ml/post_processing/tests/test_tracking_evaluation.py` (metrics on hand-built cases,
+  CSV adapter, command on a synthetic session, and proposed links equal to the links a run saves).
diff --git a/docs/claude/screenshots/admin-tracking-confirmation-step4.png b/docs/claude/screenshots/admin-tracking-confirmation-step4.png
new file mode 100644
index 000000000..3d9634bb2
Binary files /dev/null and b/docs/claude/screenshots/admin-tracking-confirmation-step4.png differ
diff --git a/requirements/base.txt b/requirements/base.txt
index be5d24b67..04e128d23 100644
--- a/requirements/base.txt
+++ b/requirements/base.txt
@@ -19,6 +19,7 @@ django-pydantic-field==0.3.10
 sentry-sdk==2.59.0  # https://github.com/getsentry/sentry-python
 django-cachalot==2.6.3
 numpy==2.1
+pgvector==0.5.0  # https://github.com/pgvector/pgvector-python
 
 # Django
 # ------------------------------------------------------------------------------