Added annotator name based progress tracking

backend/assignment.py

@@ -100,6 +100,21 @@ def completed_by_annotator(deduped):
     return result
 
 
+def saved_responses_for_round(deduped, annotator_id, video_ids):
+    """{video_id: responses} for every video in `video_ids` that `annotator_id`
+    already has a saved annotation for - lets a returning annotator (same
+    name, new session or a reload) resume with prior answers pre-filled
+    instead of starting blank. `responses` is exactly the {events, video}
+    shape the frontend's annotation state already uses, since it's what was
+    saved from that same shape originally."""
+    video_id_set = set(video_ids)
+    return {
+        video_id: record["annotations"]["responses"]
+        for (a_id, video_id), record in deduped.items()
+        if a_id == annotator_id and video_id in video_id_set
+    }
+
+
 def reserved_by_video(assignment_records, completed_by_annotator_map, now, ttl_seconds, exclude_annotator=None):
     """Open (not-yet-completed, not-yet-expired) reservations per video,
     across every OTHER annotator's assignment. A reservation stops counting

backend/main.py

@@ -553,7 +553,7 @@ def _completed_maps(fresh=False):
     )
 
 
-def _round_response(round_record, completion):
+def _round_response(round_record, completion, saved_responses=None):
     response = {
         "annotator_id": round_record["annotator_id"],
         "assignment_id": round_record["assignment_id"],
@@ -566,6 +566,12 @@ def _round_response(round_record, completion):
     if completion:
         response["completion_code"] = completion["completion_code"]
         response["completed_at"] = completion["completed_at"]
+    else:
+        # Lets a returning annotator (same name, new session or a reload)
+        # resume with prior answers pre-filled instead of the frontend
+        # starting every field blank - see EvaluationPage.jsx's initial
+        # state, which seeds from this.
+        response["saved_annotations"] = saved_responses or {}
     return response
 
 
@@ -625,7 +631,11 @@ def _create_round(annotator_id, annotator_raw, round_number):
         f"Point {annotator_id} at round {round_number}",
     )
 
-    return _round_response(round_record, completion=None)
+    # A fresh round's video_ids are, by construction, videos this annotator
+    # has never completed (build_round excludes already_completed from the
+    # candidate pool) - nothing to rehydrate yet, but saved_responses is
+    # always present in the response shape either way.
+    return _round_response(round_record, completion=None, saved_responses={})
 
 
 def get_or_create_current_round(annotator_raw):
@@ -661,13 +671,16 @@ def get_or_create_current_round(annotator_raw):
         completion = _read_json_from_repo(_completion_path(annotator_id, pointer["assignment_id"]))
 
         if completion is None:
-            _deduped, _skipped, _completed_by_video_map, completed_by_annotator_map = _completed_maps(fresh=True)
+            deduped, _skipped, _completed_by_video_map, completed_by_annotator_map = _completed_maps(fresh=True)
             completed_set = completed_by_annotator_map.get(annotator_id, set())
             all_done = len(round_record["video_ids"]) > 0 and all(
                 video_id in completed_set for video_id in round_record["video_ids"]
             )
             if not all_done:
-                return _round_response(round_record, completion=None)
+                saved_responses = assignment.saved_responses_for_round(
+                    deduped, annotator_id, round_record["video_ids"]
+                )
+                return _round_response(round_record, completion=None, saved_responses=saved_responses)
             completion = _persist_completion(annotator_id, round_record)
 
         completed_at = assignment.parse_iso(completion["completed_at"])

backend/test_assignment.py

@@ -86,6 +86,35 @@ class DedupeLatestTests(unittest.TestCase):
         self.assertEqual(skipped, 4)
 
 
+class SavedResponsesForRoundTests(unittest.TestCase):
+    def test_returns_responses_only_for_this_annotator_and_this_rounds_videos(self):
+        records = [
+            make_record("Adi", "v1", "2026-01-01T00:00:00Z", {"annotations": {"responses": {"marker": "adi-v1"}}}),
+            make_record("Adi", "v2", "2026-01-01T00:00:00Z", {"annotations": {"responses": {"marker": "adi-v2"}}}),
+            make_record(
+                "youngsun", "v1", "2026-01-01T00:00:00Z", {"annotations": {"responses": {"marker": "youngsun-v1"}}}
+            ),
+        ]
+        deduped, _skipped = assignment.dedupe_latest(records)
+
+        result = assignment.saved_responses_for_round(deduped, "adi", ["v1", "v2", "v3"])
+
+        self.assertEqual(result, {"v1": {"marker": "adi-v1"}, "v2": {"marker": "adi-v2"}})
+
+    def test_excludes_videos_outside_the_given_round(self):
+        records = [
+            make_record("Adi", "v9", "2026-01-01T00:00:00Z", {"annotations": {"responses": {"marker": "old-round"}}})
+        ]
+        deduped, _skipped = assignment.dedupe_latest(records)
+
+        result = assignment.saved_responses_for_round(deduped, "adi", ["v1", "v2"])
+
+        self.assertEqual(result, {}, "a completion from a prior round must not leak into this round's resume state")
+
+    def test_empty_deduped_returns_empty_dict(self):
+        self.assertEqual(assignment.saved_responses_for_round({}, "adi", ["v1"]), {})
+
+
 class PickBalancedTests(unittest.TestCase):
     def test_prefers_lowest_coverage(self):
         coverage = {"v1": 4, "v2": 0, "v3": 2}
@@ -356,6 +385,30 @@ class RoundLifecycleIntegrationTests(unittest.TestCase):
         self.assertEqual(result["status"], "in_progress")
         self.assertNotIn("completion_code", result)
 
+    def test_brand_new_round_has_no_saved_annotations(self):
+        result = self.backend_main.get_or_create_current_round("Scratch Tester")
+        self.assertEqual(result["saved_annotations"], {})
+
+    def test_resume_returns_saved_responses_for_completed_videos_only(self):
+        first = self.backend_main.get_or_create_current_round("Scratch Tester")
+        completed_ids = first["video_ids"][:3]
+        for video_id in completed_ids:
+            self.completed_records.append(
+                make_record(
+                    "Scratch Tester",
+                    video_id,
+                    iso(datetime.now(timezone.utc)),
+                    {"annotations": {"responses": {"video": {"tcRel": {"label": "PASS", "rationale": ""}}}}},
+                )
+            )
+
+        result = self.backend_main.get_or_create_current_round("Scratch Tester")
+
+        self.assertEqual(result["status"], "in_progress")
+        self.assertEqual(set(result["saved_annotations"].keys()), set(completed_ids))
+        for video_id in completed_ids:
+            self.assertEqual(result["saved_annotations"][video_id]["video"]["tcRel"]["label"], "PASS")
+
     def test_completion_code_persisted_once_at_twenty_of_twenty(self):
         first = self.backend_main.get_or_create_current_round("Scratch Tester")
         self._complete_round("Scratch Tester", first)

frontend/src/App.jsx

@@ -156,6 +156,17 @@ export default function App() {
     setStage("training");
   };
 
+  // A round can only ever exist for a name that has already passed training
+  // (POST /assignment is only ever called after trainingPassed is set, see
+  // the evaluation-stage effect above) - so GET /assignment/lookup finding
+  // an existing round is a reliable, read-only signal that this annotator
+  // already passed training in an earlier session. GuidelinePage already
+  // makes this exact call for its name-collision warning; this just listens
+  // in on that same result instead of adding a second request.
+  const handleGuidelineLookupResult = useCallback((data) => {
+    if (data?.exists) setTrainingPassed(true);
+  }, []);
+
   const handlePassTraining = () => {
     setTrainingPassed(true);
     setStage("evaluation");
@@ -241,6 +252,7 @@ export default function App() {
         annotatorName={annotatorName}
         apiBaseUrl={API_BASE_URL}
         onRoundFinished={fetchAssignment}
+        savedAnnotations={assignmentData.saved_annotations || {}}
       />
     );
   }
@@ -251,6 +263,7 @@ export default function App() {
       onChangeAnnotatorName={setAnnotatorName}
       onContinue={handleContinueToTraining}
       apiBaseUrl={API_BASE_URL}
+      onLookupResult={handleGuidelineLookupResult}
     />
   );
 }

frontend/src/pages/EvaluationPage.jsx

@@ -8,10 +8,38 @@ import GuidelineOverlay from "./GuidelineOverlay";
 import axisDefinitions from "../data/axisDefinitions";
 import { createEmptyAnnotations } from "../lib/promptSchema";
 
-export default function EvaluationPage({ tasks, missingVideos, annotatorName, apiBaseUrl, onRoundFinished }) {
-  const [currentIndex, setCurrentIndex] = useState(0);
-  const [taskAnswers, setTaskAnswers] = useState({});
-  const [savedSignatures, setSavedSignatures] = useState({});
+export default function EvaluationPage({
+  tasks,
+  missingVideos,
+  annotatorName,
+  apiBaseUrl,
+  onRoundFinished,
+  savedAnnotations = {}
+}) {
+  // Resume where a prior session (same annotator name, backend-tracked) left
+  // off, instead of always starting blank at video 1 - see
+  // App.jsx/main.py's get_or_create_current_round(), which returns
+  // saved_annotations for every video in this round already saved to the
+  // HF dataset. Lazy initializers run once on mount, matching the pattern
+  // already used in lib/useAnnotations.js.
+  const [currentIndex, setCurrentIndex] = useState(() => {
+    const firstUnsavedIndex = tasks.findIndex((t) => !savedAnnotations[t.taskId]);
+    return firstUnsavedIndex === -1 ? 0 : firstUnsavedIndex;
+  });
+  const [taskAnswers, setTaskAnswers] = useState(() => {
+    const initial = {};
+    tasks.forEach((t) => {
+      if (savedAnnotations[t.taskId]) initial[t.taskId] = savedAnnotations[t.taskId];
+    });
+    return initial;
+  });
+  const [savedSignatures, setSavedSignatures] = useState(() => {
+    const initial = {};
+    tasks.forEach((t) => {
+      if (savedAnnotations[t.taskId]) initial[t.taskId] = JSON.stringify(savedAnnotations[t.taskId]);
+    });
+    return initial;
+  });
   const [saving, setSaving] = useState(false);
   const [saveError, setSaveError] = useState(null);
   const [playbackRate, setPlaybackRate] = useState(1);
@@ -69,6 +97,10 @@ export default function EvaluationPage({ tasks, missingVideos, annotatorName, ap
   const hasUnsavedChanges =
     savedSignatures[currentTask.taskId] !== JSON.stringify(annotations);
 
+  // Tracks savedSignatures (confirmed saves), not taskAnswers, so an
+  // in-progress draft on the current video isn't counted as "saved" yet.
+  const savedCount = tasks.filter((t) => savedSignatures[t.taskId] !== undefined).length;
+
   const saveAnnotations = async () => {
     setSaving(true);
     setSaveError(null);
@@ -143,7 +175,8 @@ export default function EvaluationPage({ tasks, missingVideos, annotatorName, ap
 
         <div className="eval-progress">
           <span>
-            Video {currentIndex + 1} of {tasks.length} · Annotator: {annotatorName}
+            Video {currentIndex + 1} of {tasks.length} ({savedCount} saved) · Annotator:{" "}
+            {annotatorName}
           </span>
           <button
             type="button"

frontend/src/pages/GuidelinePage.jsx

@@ -2,7 +2,13 @@
 import React, { useEffect, useState } from "react";
 import GuidelineContent from "./GuidelineContent";
 
-export default function GuidelinePage({ annotatorName, onChangeAnnotatorName, onContinue, apiBaseUrl }) {
+export default function GuidelinePage({
+  annotatorName,
+  onChangeAnnotatorName,
+  onContinue,
+  apiBaseUrl,
+  onLookupResult
+}) {
   const nameIsValid = annotatorName.trim().length > 0;
 
   // Lightweight name-collision guard: there's no login, so two different
@@ -27,7 +33,13 @@ export default function GuidelinePage({ annotatorName, onChangeAnnotatorName, on
       fetch(`${apiBaseUrl}/assignment/lookup?annotator=${encodeURIComponent(name)}`)
         .then((res) => (res.ok ? res.json() : { exists: false }))
         .then((data) => {
-          if (!cancelled) setCollisionInfo(data.exists ? data : null);
+          if (cancelled) return;
+          setCollisionInfo(data.exists ? data : null);
+          // A round only ever exists for a name that already passed
+          // training (see App.jsx's handleGuidelineLookupResult) - reuse
+          // this same lookup instead of firing a second request just to
+          // check that.
+          onLookupResult?.(data);
         })
         .catch(() => {
           // Fail open - this check is advisory, never block name entry on a lookup error.
@@ -39,7 +51,7 @@ export default function GuidelinePage({ annotatorName, onChangeAnnotatorName, on
       cancelled = true;
       clearTimeout(timer);
     };
-  }, [annotatorName, apiBaseUrl]);
+  }, [annotatorName, apiBaseUrl, onLookupResult]);
 
   const hasUnacknowledgedCollision = Boolean(collisionInfo) && !collisionAcknowledged;
 
@@ -55,13 +67,18 @@ export default function GuidelinePage({ annotatorName, onChangeAnnotatorName, on
               placeholder="Your name"
             />
           </label>
+          <p className="muted validation-hint">
+            Use the same name every time you return — an in-progress round resumes
+            automatically, saved answers included.
+          </p>
           {!nameIsValid && <p className="muted validation-hint">Enter your name to continue.</p>}
 
           {collisionInfo && (
             <div className="callout collision-warning">
-              <span className="k">Name already in use</span>
+              <span className="k">Is this you?</span>
               An assignment already exists for &ldquo;{annotatorName.trim()}&rdquo; (
-              {collisionInfo.completed} of {collisionInfo.total} completed).
+              {collisionInfo.completed} of {collisionInfo.total} completed) — if so, you'll
+              resume with your saved answers already filled in.
               <label className="confirmation-row">
                 <input
                   type="checkbox"