fix(face-clusters): age recluster results from completion; harden poll loop

Addresses review feedback on the async reclustering flow.

- ReclusterTask now records finished_at, and the cleanup loop ages terminal
  results from completion time instead of creation time. Previously a job that
  ran close to the TTL could be reaped almost immediately after finishing,
  making polling clients see a 404 instead of the result.

- useGlobalRecluster now polls with a self-scheduling setTimeout (the next tick
  is queued only after the current request resolves, so status requests can't
  stack/overlap) and guards every async callback with a monotonically
  increasing run id. A newer trigger() — or unmount — invalidates older runs so
  they cannot keep polling or overwrite state, fixing the orphaned-interval leak
  on repeated triggers.

Author: VanshajPoonia

backend/app/routes/face_clusters.py

@@ -54,6 +54,7 @@ class ReclusterTask:
     faces_skipped: Optional[int] = None
     message: Optional[str] = None
     created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    finished_at: Optional[datetime] = None
     task: Optional[asyncio.Task] = None
 
 
@@ -66,9 +67,10 @@ class ReclusterTask:
 # with no await between check-and-set.
 _active_recluster_task_id: Optional[str] = None
 
-# How long a finished task's result is retained for polling before the cleanup
-# loop reaps it. Running tasks are never reaped (they are bounded to one by the
-# concurrency guard above).
+# How long a finished task's result is retained for polling, measured from when
+# it finished (not when it started) so a long-running job's result isn't reaped
+# almost immediately after completion. Running tasks are never reaped (they are
+# bounded to one by the concurrency guard above).
 RECLUSTER_TASK_TTL_MINUTES = 15
 
 
@@ -94,8 +96,10 @@ async def _run_global_recluster(task_id: str):
         entry.status = "error"
         entry.message = f"Global reclustering failed: {str(e)}"
     finally:
-        # Release the concurrency guard so a new job can be started, while the
-        # finished result stays in recluster_tasks for the client to poll.
+        # Stamp completion time so cleanup ages the result from when it finished,
+        # and release the concurrency guard so a new job can be started, while
+        # the finished result stays in recluster_tasks for the client to poll.
+        entry.finished_at = datetime.now(timezone.utc)
         if _active_recluster_task_id == task_id:
             _active_recluster_task_id = None
 
@@ -113,7 +117,8 @@ async def _cleanup_stale_recluster_tasks():
             tid
             for tid, entry in recluster_tasks.items()
             if entry.status != "running"
-            and (now - entry.created_at).total_seconds()
+            and entry.finished_at is not None
+            and (now - entry.finished_at).total_seconds()
             > RECLUSTER_TASK_TTL_MINUTES * 60
         ]
         for tid in stale:

frontend/src/hooks/useGlobalRecluster.tsx

@@ -39,34 +39,54 @@ const idleState: ReclusterState = {
  */
 export function useGlobalRecluster() {
   const queryClient = useQueryClient();
-  const pollHandleRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const pollTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // Identifies the latest trigger() call. Every async callback captures the id
+  // it started with and bails if a newer trigger (or unmount) has since bumped
+  // it, so stale runs can't update state or keep polling.
+  const runIdRef = useRef(0);
   const [state, setState] = useState<ReclusterState>(idleState);
 
   const stopPolling = useCallback(() => {
-    if (pollHandleRef.current) {
-      clearInterval(pollHandleRef.current);
-      pollHandleRef.current = null;
+    if (pollTimeoutRef.current) {
+      clearTimeout(pollTimeoutRef.current);
+      pollTimeoutRef.current = null;
     }
   }, []);
 
-  useEffect(() => stopPolling, [stopPolling]);
+  // On unmount, invalidate any in-flight run and stop polling.
+  useEffect(() => {
+    return () => {
+      runIdRef.current += 1;
+      stopPolling();
+    };
+  }, [stopPolling]);
 
   const trigger = useCallback(() => {
+    const runId = runIdRef.current + 1;
+    runIdRef.current = runId;
+    const isActive = () => runId === runIdRef.current;
+
     stopPolling();
     setState({ ...idleState, isPending: true });
 
     startGlobalReclustering()
       .then((startRes) => {
+        if (!isActive()) return;
+
         const taskId = startRes.data?.task_id;
         if (!taskId) {
           throw new Error('Backend did not return a task_id for reclustering.');
         }
 
-        pollHandleRef.current = setInterval(async () => {
+        // Self-scheduling poll: the next tick is only queued after the current
+        // request resolves, so requests can't stack up or overlap.
+        const poll = async () => {
           try {
             const statusRes = await getGlobalReclusterStatus(taskId);
+            if (!isActive()) return;
 
             if (statusRes.data?.status === 'running') {
+              pollTimeoutRef.current = setTimeout(poll, POLL_INTERVAL_MS);
               return;
             }
 
@@ -92,6 +112,7 @@ export function useGlobalRecluster() {
               successMessage: statusRes.message,
             });
           } catch (err) {
+            if (!isActive()) return;
             stopPolling();
             setState({
               ...idleState,
@@ -100,9 +121,12 @@ export function useGlobalRecluster() {
               errorMessage: getErrorMessage(err),
             });
           }
-        }, POLL_INTERVAL_MS);
+        };
+
+        poll();
       })
       .catch((err) => {
+        if (!isActive()) return;
         setState({
           ...idleState,
           isError: true,