From f5d529de6389ab0c53a5ece8a2c241b5131c852b Mon Sep 17 00:00:00 2001
From: Collin Beczak <ctbeczak08@gmail.com>
Date: Tue, 28 Jul 2026 23:44:05 -0500
Subject: [PATCH 1/6] Add lock-conflict modal for the new one-lock-per-user
 backend rule

The backend now allows a user only one active task lock at a time and
returns 409 with the held lock's details when a second lock attempt
conflicts. Add getLockConflict to parse that response and a
useLockConflict hook that shows LockConflictModal, releases the held
task via the existing unlock endpoint, and retries the original
action on confirm. Wire it into TaskContext's auto-lock/manual lock
and into TaskActionModal's bundle create/update flow, and add
bundledTasks to the LockedTaskData type.
---
 .../Pages/TaskEditPage/TaskActionModal.tsx    | 347 ++++++++++--------
 .../TaskActions/LockConflictModal.tsx         |  77 ++++
 .../TaskEditPage/contexts/TaskContext.tsx     |  53 ++-
 src/hooks/useLockConflict.test.ts             | 133 +++++++
 src/hooks/useLockConflict.ts                  |  53 +++
 src/lib/apiError.test.ts                      |  53 ++-
 src/lib/apiError.ts                           |  30 ++
 src/types/openApiTypes.ts                     |  99 ++---
 8 files changed, 609 insertions(+), 236 deletions(-)
 create mode 100644 src/components/Pages/TaskEditPage/TaskActions/LockConflictModal.tsx
 create mode 100644 src/hooks/useLockConflict.test.ts
 create mode 100644 src/hooks/useLockConflict.ts

diff --git a/src/components/Pages/TaskEditPage/TaskActionModal.tsx b/src/components/Pages/TaskEditPage/TaskActionModal.tsx
index ebec6aa02..35bf03cd6 100644
--- a/src/components/Pages/TaskEditPage/TaskActionModal.tsx
+++ b/src/components/Pages/TaskEditPage/TaskActionModal.tsx
@@ -24,12 +24,14 @@ import {
   SelectValue,
 } from '@/components/ui/Select'
 import { Textarea } from '@/components/ui/Textarea'
+import { useLockConflict } from '@/hooks/useLockConflict'
 import { useIntl } from '@/i18n'
 import { getApiErrorMessage } from '@/lib/apiError'
 import { logger } from '@/lib/logger'
 import { getStatusLabel } from '@/lib/taskConstants'
 import type { Task } from '@/types/Task'
 import { PENDING_BUNDLE_ID, useTaskBundleContext } from './contexts/TaskBundleContext'
+import { LockConflictModal } from './TaskActions/LockConflictModal'
 import { TaskNearbyMap } from './TaskNearbyMap'
 
 interface TaskActionModalProps {
@@ -79,6 +81,7 @@ export const TaskActionModal = ({
   const updateBundleStatusMutation = api.taskBundle.useUpdateTaskBundleStatus()
   const createBundleMutation = api.taskBundle.useCreateTaskBundle()
   const updateBundleMutation = api.taskBundle.useUpdateTaskBundle()
+  const lockConflict = useLockConflict()
   const { activeBundle, initialBundle } = useTaskBundleContext()
   const currentStatus = task.status ?? 0
   const currentStatusLabel =
@@ -143,7 +146,10 @@ export const TaskActionModal = ({
       }
 
       if (comment.trim()) {
-        addTaskCommentMutation.mutate({ taskId: task.id, commentText: comment.trim() })
+        addTaskCommentMutation.mutate({
+          taskId: task.id,
+          commentText: comment.trim(),
+        })
       }
 
       toast.success(
@@ -155,7 +161,10 @@ export const TaskActionModal = ({
       )
 
       if (nextTaskType === 'nearby' && selectedNearbyTaskId) {
-        await navigate({ to: '/tasks/$taskId', params: { taskId: String(selectedNearbyTaskId) } })
+        await navigate({
+          to: '/tasks/$taskId',
+          params: { taskId: String(selectedNearbyTaskId) },
+        })
       } else {
         toast.info(
           t('taskEditPage.taskActionModal.toast.loadingNext', undefined, 'Loading next task...')
@@ -163,7 +172,10 @@ export const TaskActionModal = ({
         try {
           const randomTasks = await api.challenge.getRandomTask(task.parent, queryClient)
           if (randomTasks && randomTasks.length > 0) {
-            await navigate({ to: '/tasks/$taskId', params: { taskId: String(randomTasks[0].id) } })
+            await navigate({
+              to: '/tasks/$taskId',
+              params: { taskId: String(randomTasks[0].id) },
+            })
           } else {
             toast.info(
               t(
@@ -188,6 +200,11 @@ export const TaskActionModal = ({
 
       onOpenChange(false)
     } catch (error) {
+      const isLockConflict = await lockConflict.handleError(error, () => {
+        void handleSubmit()
+      })
+      if (isLockConflict) return
+
       logger.error('Error updating task', { error: String(error) })
       toast.error(
         (await getApiErrorMessage(error)) ??
@@ -212,174 +229,186 @@ export const TaskActionModal = ({
   }
 
   return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent size="xl" className="max-h-[90vh] overflow-y-auto">
-        <DialogHeader>
-          <DialogTitle>
-            {t('taskEditPage.taskActionModal.title', undefined, 'Complete Task Action')}
-          </DialogTitle>
-          <DialogDescription>
-            {t(
-              'taskEditPage.taskActionModal.description',
-              undefined,
-              'Update the task status and optionally add a comment or tags'
-            )}
-          </DialogDescription>
-        </DialogHeader>
+    <>
+      <Dialog open={open} onOpenChange={onOpenChange}>
+        <DialogContent size="xl" className="max-h-[90vh] overflow-y-auto">
+          <DialogHeader>
+            <DialogTitle>
+              {t('taskEditPage.taskActionModal.title', undefined, 'Complete Task Action')}
+            </DialogTitle>
+            <DialogDescription>
+              {t(
+                'taskEditPage.taskActionModal.description',
+                undefined,
+                'Update the task status and optionally add a comment or tags'
+              )}
+            </DialogDescription>
+          </DialogHeader>
 
-        <div className="space-y-6 py-4">
-          {/* Status Transition */}
-          <div className="space-y-2">
-            <Label>
-              {t('taskEditPage.taskActionModal.statusChange', undefined, 'Status Change')}
-            </Label>
-            <div className="flex items-center gap-3">
-              <div className="flex items-center gap-2 rounded-lg bg-zinc-100 px-3 py-2 dark:bg-slate-700">
-                <span className="font-medium text-sm">{currentStatusLabel}</span>
+          <div className="space-y-6 py-4">
+            {/* Status Transition */}
+            <div className="space-y-2">
+              <Label>
+                {t('taskEditPage.taskActionModal.statusChange', undefined, 'Status Change')}
+              </Label>
+              <div className="flex items-center gap-3">
+                <div className="flex items-center gap-2 rounded-lg bg-zinc-100 px-3 py-2 dark:bg-slate-700">
+                  <span className="font-medium text-sm">{currentStatusLabel}</span>
+                </div>
+                <ArrowRight className="h-4 w-4 text-zinc-500" />
+                <Select
+                  value={String(newStatus)}
+                  onValueChange={(value) => setNewStatus(Number(value))}
+                >
+                  <SelectTrigger className="w-[200px]">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {STATUS_OPTIONS.map((option) => (
+                      <SelectItem key={option.value} value={String(option.value)}>
+                        {option.label}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
               </div>
-              <ArrowRight className="h-4 w-4 text-zinc-500" />
-              <Select
-                value={String(newStatus)}
-                onValueChange={(value) => setNewStatus(Number(value))}
-              >
-                <SelectTrigger className="w-[200px]">
-                  <SelectValue />
-                </SelectTrigger>
-                <SelectContent>
-                  {STATUS_OPTIONS.map((option) => (
-                    <SelectItem key={option.value} value={String(option.value)}>
-                      {option.label}
-                    </SelectItem>
-                  ))}
-                </SelectContent>
-              </Select>
             </div>
-          </div>
 
-          {/* Comment */}
-          <div className="space-y-2">
-            <Label htmlFor={commentId}>
-              {t('taskEditPage.taskActionModal.commentLabel', undefined, 'Comment (Optional)')}
-            </Label>
-            <Textarea
-              id={commentId}
-              placeholder={t(
-                'taskEditPage.taskActionModal.commentPlaceholder',
-                undefined,
-                'Add any notes or comments about this task...'
-              )}
-              value={comment}
-              onChange={(e) => setComment(e.target.value)}
-              rows={3}
-            />
-          </div>
+            {/* Comment */}
+            <div className="space-y-2">
+              <Label htmlFor={commentId}>
+                {t('taskEditPage.taskActionModal.commentLabel', undefined, 'Comment (Optional)')}
+              </Label>
+              <Textarea
+                id={commentId}
+                placeholder={t(
+                  'taskEditPage.taskActionModal.commentPlaceholder',
+                  undefined,
+                  'Add any notes or comments about this task...'
+                )}
+                value={comment}
+                onChange={(e) => setComment(e.target.value)}
+                rows={3}
+              />
+            </div>
 
-          {/* Tags */}
-          <div className="space-y-2">
-            <Label htmlFor={tagsId}>
-              {t('taskEditPage.taskActionModal.tagsLabel', undefined, 'Tags (Optional)')}
-            </Label>
-            <Input
-              id={tagsId}
-              placeholder={t(
-                'taskEditPage.taskActionModal.tagsPlaceholder',
-                undefined,
-                'Enter tags separated by commas (e.g., needs-review, complex)'
-              )}
-              value={tags}
-              onChange={(e) => setTags(e.target.value)}
-            />
-            <p className="text-xs text-zinc-500">
-              {t(
-                'taskEditPage.taskActionModal.tagsHint',
-                undefined,
-                'Separate multiple tags with commas'
-              )}
-            </p>
-          </div>
+            {/* Tags */}
+            <div className="space-y-2">
+              <Label htmlFor={tagsId}>
+                {t('taskEditPage.taskActionModal.tagsLabel', undefined, 'Tags (Optional)')}
+              </Label>
+              <Input
+                id={tagsId}
+                placeholder={t(
+                  'taskEditPage.taskActionModal.tagsPlaceholder',
+                  undefined,
+                  'Enter tags separated by commas (e.g., needs-review, complex)'
+                )}
+                value={tags}
+                onChange={(e) => setTags(e.target.value)}
+              />
+              <p className="text-xs text-zinc-500">
+                {t(
+                  'taskEditPage.taskActionModal.tagsHint',
+                  undefined,
+                  'Separate multiple tags with commas'
+                )}
+              </p>
+            </div>
 
-          {/* Next Task Selection */}
-          <div className="space-y-3">
-            <Label>{t('taskEditPage.taskActionModal.nextTask', undefined, 'Next Task')}</Label>
-            <RadioGroup
-              value={nextTaskType}
-              onValueChange={(value) => setNextTaskType(value as 'nearby' | 'random')}
-            >
-              <div className="space-y-3">
-                <div className="flex items-start space-x-3">
-                  <RadioGroupItem value="random" id={randomId} className="mt-1" />
-                  <div className="flex-1">
-                    <Label
-                      htmlFor={randomId}
-                      className="flex cursor-pointer items-center gap-2 font-medium"
-                    >
-                      <Shuffle className="h-4 w-4" />
-                      {t(
-                        'taskEditPage.taskActionModal.randomTask.label',
-                        undefined,
-                        'Random High Priority Task'
-                      )}
-                    </Label>
-                    <p className="mt-1 text-xs text-zinc-500">
-                      {t(
-                        'taskEditPage.taskActionModal.randomTask.description',
-                        undefined,
-                        'Load the next highest priority task from this challenge'
-                      )}
-                    </p>
+            {/* Next Task Selection */}
+            <div className="space-y-3">
+              <Label>{t('taskEditPage.taskActionModal.nextTask', undefined, 'Next Task')}</Label>
+              <RadioGroup
+                value={nextTaskType}
+                onValueChange={(value) => setNextTaskType(value as 'nearby' | 'random')}
+              >
+                <div className="space-y-3">
+                  <div className="flex items-start space-x-3">
+                    <RadioGroupItem value="random" id={randomId} className="mt-1" />
+                    <div className="flex-1">
+                      <Label
+                        htmlFor={randomId}
+                        className="flex cursor-pointer items-center gap-2 font-medium"
+                      >
+                        <Shuffle className="h-4 w-4" />
+                        {t(
+                          'taskEditPage.taskActionModal.randomTask.label',
+                          undefined,
+                          'Random High Priority Task'
+                        )}
+                      </Label>
+                      <p className="mt-1 text-xs text-zinc-500">
+                        {t(
+                          'taskEditPage.taskActionModal.randomTask.description',
+                          undefined,
+                          'Load the next highest priority task from this challenge'
+                        )}
+                      </p>
+                    </div>
                   </div>
-                </div>
 
-                <div className="flex items-start space-x-3">
-                  <RadioGroupItem value="nearby" id={nearbyId} className="mt-1" />
-                  <div className="flex-1">
-                    <Label
-                      htmlFor={nearbyId}
-                      className="flex cursor-pointer items-center gap-2 font-medium"
-                    >
-                      <MapPin className="h-4 w-4" />
-                      {t('taskEditPage.taskActionModal.nearbyTask.label', undefined, 'Nearby Task')}
-                    </Label>
-                    <p className="mt-1 text-xs text-zinc-500">
-                      {t(
-                        'taskEditPage.taskActionModal.nearbyTask.description',
-                        undefined,
-                        'Select a task near the current one, or auto-select the nearest'
-                      )}
-                    </p>
+                  <div className="flex items-start space-x-3">
+                    <RadioGroupItem value="nearby" id={nearbyId} className="mt-1" />
+                    <div className="flex-1">
+                      <Label
+                        htmlFor={nearbyId}
+                        className="flex cursor-pointer items-center gap-2 font-medium"
+                      >
+                        <MapPin className="h-4 w-4" />
+                        {t(
+                          'taskEditPage.taskActionModal.nearbyTask.label',
+                          undefined,
+                          'Nearby Task'
+                        )}
+                      </Label>
+                      <p className="mt-1 text-xs text-zinc-500">
+                        {t(
+                          'taskEditPage.taskActionModal.nearbyTask.description',
+                          undefined,
+                          'Select a task near the current one, or auto-select the nearest'
+                        )}
+                      </p>
+                    </div>
                   </div>
                 </div>
-              </div>
-            </RadioGroup>
+              </RadioGroup>
 
-            {/* Nearby Map */}
-            {nextTaskType === 'nearby' && (
-              <div className="mt-3 rounded-lg border border-zinc-200 p-3 dark:border-slate-700">
-                <TaskNearbyMap
-                  currentTask={task}
-                  selectedTaskId={selectedNearbyTaskId}
-                  onTaskSelect={setSelectedNearbyTaskId}
-                />
-              </div>
-            )}
+              {/* Nearby Map */}
+              {nextTaskType === 'nearby' && (
+                <div className="mt-3 rounded-lg border border-zinc-200 p-3 dark:border-slate-700">
+                  <TaskNearbyMap
+                    currentTask={task}
+                    selectedTaskId={selectedNearbyTaskId}
+                    onTaskSelect={setSelectedNearbyTaskId}
+                  />
+                </div>
+              )}
+            </div>
           </div>
-        </div>
 
-        <DialogFooter>
-          <Button onClick={handleCancel} disabled={isSubmitting}>
-            {t('common.cancel', undefined, 'Cancel')}
-          </Button>
-          <Button variant="outline" onClick={handleSubmit} disabled={isSubmitting}>
-            {isSubmitting
-              ? t('common.submitting', undefined, 'Submitting...')
-              : t(
-                  'taskEditPage.taskActionModal.completeAndContinue',
-                  undefined,
-                  'Complete & Continue'
-                )}
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
+          <DialogFooter>
+            <Button onClick={handleCancel} disabled={isSubmitting}>
+              {t('common.cancel', undefined, 'Cancel')}
+            </Button>
+            <Button variant="outline" onClick={handleSubmit} disabled={isSubmitting}>
+              {isSubmitting
+                ? t('common.submitting', undefined, 'Submitting...')
+                : t(
+                    'taskEditPage.taskActionModal.completeAndContinue',
+                    undefined,
+                    'Complete & Continue'
+                  )}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+      <LockConflictModal
+        conflict={lockConflict.conflict}
+        onConfirm={lockConflict.confirm}
+        onCancel={lockConflict.cancel}
+        busy={lockConflict.isReleasing}
+      />
+    </>
   )
 }
diff --git a/src/components/Pages/TaskEditPage/TaskActions/LockConflictModal.tsx b/src/components/Pages/TaskEditPage/TaskActions/LockConflictModal.tsx
new file mode 100644
index 000000000..4c2975c9d
--- /dev/null
+++ b/src/components/Pages/TaskEditPage/TaskActions/LockConflictModal.tsx
@@ -0,0 +1,77 @@
+import { Lock } from 'lucide-react'
+import { Button } from '@/components/ui/Button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/Dialog'
+import { useIntl } from '@/i18n'
+import type { LockConflict } from '@/lib/apiError'
+
+interface LockConflictModalProps {
+  conflict: LockConflict | null
+  onConfirm: () => void
+  onCancel: () => void
+  busy?: boolean
+}
+
+/**
+ * Shown when the user tries to lock a task while already holding a lock on a different one
+ * (a user may only hold one active edit lock at a time). Lets them release the held lock and
+ * take the new one instead, or cancel and keep working on what they already have locked.
+ */
+export const LockConflictModal = ({
+  conflict,
+  onConfirm,
+  onCancel,
+  busy,
+}: LockConflictModalProps) => {
+  const { t } = useIntl()
+  const bundledCount = conflict?.bundledTasks.length ?? 0
+
+  return (
+    <Dialog open={conflict != null} onOpenChange={(open) => !open && onCancel()}>
+      <DialogContent size="md">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <Lock className="size-5 text-amber-500" aria-hidden="true" />
+            {t('taskEditPage.lockConflictModal.title', undefined, 'You already have a task locked')}
+          </DialogTitle>
+          <DialogDescription>
+            {conflict?.parentName
+              ? t(
+                  'taskEditPage.lockConflictModal.descriptionWithParent',
+                  { parentName: conflict.parentName },
+                  'You currently have a task locked in "{parentName}". Unlock it and lock this task instead?'
+                )
+              : t(
+                  'taskEditPage.lockConflictModal.description',
+                  undefined,
+                  'You currently have another task locked. Unlock it and lock this task instead?'
+                )}
+            {bundledCount > 0 &&
+              ' ' +
+                t(
+                  'taskEditPage.lockConflictModal.bundleNote',
+                  { count: bundledCount },
+                  '{count, plural, one {This will also release # bundled task.} other {This will also release # bundled tasks.}}'
+                )}
+          </DialogDescription>
+        </DialogHeader>
+        <DialogFooter>
+          <Button variant="outline" onClick={onCancel} disabled={busy}>
+            {t('common.cancel', undefined, 'Cancel')}
+          </Button>
+          <Button onClick={onConfirm} disabled={busy}>
+            {busy
+              ? t('taskEditPage.lockConflictModal.unlocking', undefined, 'Unlocking…')
+              : t('taskEditPage.lockConflictModal.confirm', undefined, 'Unlock and continue')}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx b/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
index 95e848aeb..b17577461 100644
--- a/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
+++ b/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
@@ -3,7 +3,9 @@ import type { ReactNode } from 'react'
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react'
 import { api } from '@/api'
 import { useAuthContext } from '@/contexts/AuthContext'
+import { useLockConflict } from '@/hooks/useLockConflict'
 import type { Task } from '@/types/Task'
+import { LockConflictModal } from '../TaskActions/LockConflictModal'
 
 // Statuses that allow editing: Created (0), Skipped (3), Too Hard/Can't Complete (6)
 export const EDITABLE_STATUSES = [0, 3, 6]
@@ -23,6 +25,7 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
   const { isAuthenticated } = useAuthContext()
   const lockTaskMutation = api.task.useLockTask()
   const unlockTaskMutation = api.task.useUnlockTask()
+  const lockConflict = useLockConflict()
   const hasAttemptedLock = useRef(false)
   const [isLocked, setIsLocked] = useState(false)
 
@@ -33,20 +36,33 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
     setIsLocked(false)
   }, [task?.id])
 
+  // Shared by the auto-lock effect and the manual lockTask() call so both go through the
+  // same conflict handling: on a 409 (user already holds a different lock), the
+  // LockConflictModal is shown and this same taskId is retried if they confirm.
+  const attemptLock = useCallback(
+    (taskId: number) => {
+      lockTaskMutation.mutate(taskId, {
+        onSuccess: () => {
+          setIsLocked(true)
+          lockedTaskIdRef.current = taskId
+        },
+        onError: async (error) => {
+          const handled = await lockConflict.handleError(error, () => attemptLock(taskId))
+          if (!handled) setIsLocked(false)
+        },
+      })
+    },
+    [lockTaskMutation, lockConflict]
+  )
+
   useEffect(() => {
     if (!task || !isAuthenticated || hasAttemptedLock.current) return
     if (!EDITABLE_STATUSES.includes(task.status ?? 0)) return
     if (challenge?.paused) return
 
     hasAttemptedLock.current = true
-    lockTaskMutation.mutate(task.id, {
-      onSuccess: () => {
-        setIsLocked(true)
-        lockedTaskIdRef.current = task.id
-      },
-      onError: () => setIsLocked(false),
-    })
-  }, [task, isAuthenticated, challenge?.paused, lockTaskMutation])
+    attemptLock(task.id)
+  }, [task, isAuthenticated, challenge?.paused, attemptLock])
 
   useEffect(() => {
     return () => {
@@ -60,13 +76,8 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
 
   const lockTask = useCallback(() => {
     if (!task || challenge?.paused) return
-    lockTaskMutation.mutate(task.id, {
-      onSuccess: () => {
-        setIsLocked(true)
-        lockedTaskIdRef.current = task.id
-      },
-    })
-  }, [task, challenge?.paused, lockTaskMutation])
+    attemptLock(task.id)
+  }, [task, challenge?.paused, attemptLock])
 
   const unlockTask = useCallback(() => {
     if (!task) return
@@ -86,7 +97,17 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
     [task, isLocked, lockTaskMutation.isPending, lockTask, unlockTask]
   )
 
-  return <TaskContext.Provider value={value}>{children}</TaskContext.Provider>
+  return (
+    <TaskContext.Provider value={value}>
+      {children}
+      <LockConflictModal
+        conflict={lockConflict.conflict}
+        onConfirm={lockConflict.confirm}
+        onCancel={lockConflict.cancel}
+        busy={lockConflict.isReleasing}
+      />
+    </TaskContext.Provider>
+  )
 }
 
 export const useTaskContext = () => {
diff --git a/src/hooks/useLockConflict.test.ts b/src/hooks/useLockConflict.test.ts
new file mode 100644
index 000000000..7f8629825
--- /dev/null
+++ b/src/hooks/useLockConflict.test.ts
@@ -0,0 +1,133 @@
+// @vitest-environment happy-dom
+import type { NormalizedOptions } from 'ky'
+import { HTTPError } from 'ky'
+import { act } from 'react'
+import { describe, expect, it, vi } from 'vitest'
+import { api } from '@/api'
+import { renderHook } from '@/test/renderHook'
+import { useLockConflict } from './useLockConflict'
+
+vi.mock('@/api', () => ({
+  api: { task: { useUnlockTask: vi.fn() } },
+}))
+
+type UnlockMutate = ReturnType<typeof api.task.useUnlockTask>['mutate']
+
+const mockUnlock = (mutate: UnlockMutate = vi.fn((_id, opts) => opts?.onSuccess?.())) => {
+  vi.mocked(api.task.useUnlockTask).mockReturnValue({
+    mutate,
+    isPending: false,
+  } as unknown as ReturnType<typeof api.task.useUnlockTask>)
+  return mutate
+}
+
+const makeLockConflictError = (body: Record<string, unknown>) => {
+  const response = new Response(JSON.stringify(body), { status: 409 })
+  const request = new Request('http://example.test/api/v2/task/1/start')
+  return new HTTPError(response, request, {} as NormalizedOptions)
+}
+
+describe('useLockConflict', () => {
+  it('starts with no conflict', () => {
+    mockUnlock()
+    const { result } = renderHook(() => useLockConflict())
+
+    expect(result.current.conflict).toBeNull()
+  })
+
+  it('handleError returns false and leaves conflict unset for a non-lock error', async () => {
+    mockUnlock()
+    const { result } = renderHook(() => useLockConflict())
+    const retry = vi.fn()
+
+    let handled = true
+    await act(async () => {
+      handled = await result.current.handleError(new Error('boom'), retry)
+    })
+
+    expect(handled).toBe(false)
+    expect(result.current.conflict).toBeNull()
+    expect(retry).not.toHaveBeenCalled()
+  })
+
+  it('handleError stores the conflict details for a 409 lock conflict', async () => {
+    mockUnlock()
+    const { result } = renderHook(() => useLockConflict())
+    const error = makeLockConflictError({
+      lockedTaskId: 42,
+      parentName: 'My Challenge',
+      bundledTasks: [43],
+    })
+
+    let handled = false
+    await act(async () => {
+      handled = await result.current.handleError(error, vi.fn())
+    })
+
+    expect(handled).toBe(true)
+    expect(result.current.conflict).toEqual({
+      lockedTaskId: 42,
+      parentName: 'My Challenge',
+      bundledTasks: [43],
+      startedAt: undefined,
+    })
+  })
+
+  it('confirm releases the held lock and retries the original action', async () => {
+    const mutate = mockUnlock()
+    const { result } = renderHook(() => useLockConflict())
+    const retry = vi.fn()
+    const error = makeLockConflictError({ lockedTaskId: 99, bundledTasks: [] })
+
+    await act(async () => {
+      await result.current.handleError(error, retry)
+    })
+    expect(result.current.conflict?.lockedTaskId).toBe(99)
+
+    act(() => {
+      result.current.confirm()
+    })
+
+    expect(mutate).toHaveBeenCalledWith(
+      99,
+      expect.objectContaining({ onSuccess: expect.any(Function) })
+    )
+    expect(retry).toHaveBeenCalledTimes(1)
+    expect(result.current.conflict).toBeNull()
+  })
+
+  it('confirm does nothing when there is no active conflict', () => {
+    const mutate = mockUnlock()
+    const { result } = renderHook(() => useLockConflict())
+
+    act(() => {
+      result.current.confirm()
+    })
+
+    expect(mutate).not.toHaveBeenCalled()
+  })
+
+  it('cancel clears the conflict without releasing anything', async () => {
+    const mutate = mockUnlock()
+    const { result } = renderHook(() => useLockConflict())
+    const retry = vi.fn()
+    const error = makeLockConflictError({ lockedTaskId: 7, bundledTasks: [] })
+
+    await act(async () => {
+      await result.current.handleError(error, retry)
+    })
+
+    act(() => {
+      result.current.cancel()
+    })
+
+    expect(result.current.conflict).toBeNull()
+    expect(mutate).not.toHaveBeenCalled()
+
+    // Confirming after a cancel must not resurrect the stale retry.
+    act(() => {
+      result.current.confirm()
+    })
+    expect(retry).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/hooks/useLockConflict.ts b/src/hooks/useLockConflict.ts
new file mode 100644
index 000000000..23b1036df
--- /dev/null
+++ b/src/hooks/useLockConflict.ts
@@ -0,0 +1,53 @@
+import { useCallback, useRef, useState } from 'react'
+import { api } from '@/api'
+import { getLockConflict, type LockConflict } from '@/lib/apiError'
+
+/**
+ * A user may only hold one active edit lock at a time. When an attempt to lock a task (or
+ * create/update a bundle) fails with a 409 conflict, this captures the details of the lock the
+ * user already holds elsewhere so a confirm-and-switch modal can be shown, then handles
+ * releasing that lock and retrying the original action.
+ */
+export const useLockConflict = () => {
+  const unlockTaskMutation = api.task.useUnlockTask()
+  const [conflict, setConflict] = useState<LockConflict | null>(null)
+  const pendingRetryRef = useRef<(() => void) | null>(null)
+
+  /**
+   * Call from a mutation's onError. If `error` is a lock conflict, stores it (triggering the
+   * modal) and remembers `retry` to re-run once the user confirms. Returns whether it was
+   * a lock conflict, so callers can fall back to normal error handling otherwise.
+   */
+  const handleError = useCallback(async (error: unknown, retry: () => void): Promise<boolean> => {
+    const parsed = await getLockConflict(error)
+    if (!parsed) return false
+    setConflict(parsed)
+    pendingRetryRef.current = retry
+    return true
+  }, [])
+
+  const confirm = useCallback(() => {
+    if (!conflict) return
+    unlockTaskMutation.mutate(conflict.lockedTaskId, {
+      onSuccess: () => {
+        setConflict(null)
+        const retry = pendingRetryRef.current
+        pendingRetryRef.current = null
+        retry?.()
+      },
+    })
+  }, [conflict, unlockTaskMutation])
+
+  const cancel = useCallback(() => {
+    setConflict(null)
+    pendingRetryRef.current = null
+  }, [])
+
+  return {
+    conflict,
+    handleError,
+    confirm,
+    cancel,
+    isReleasing: unlockTaskMutation.isPending,
+  }
+}
diff --git a/src/lib/apiError.test.ts b/src/lib/apiError.test.ts
index d5f32610b..2e8899fe7 100644
--- a/src/lib/apiError.test.ts
+++ b/src/lib/apiError.test.ts
@@ -1,7 +1,7 @@
 import type { NormalizedOptions } from 'ky'
 import { HTTPError } from 'ky'
 import { describe, expect, it } from 'vitest'
-import { getApiErrorMessage } from './apiError.ts'
+import { getApiErrorMessage, getLockConflict } from './apiError.ts'
 
 const makeHttpError = (body: unknown, status = 400) => {
   const response = new Response(JSON.stringify(body), { status })
@@ -42,3 +42,54 @@ describe('getApiErrorMessage', () => {
     await expect(getApiErrorMessage(error)).resolves.toBeUndefined()
   })
 })
+
+describe('getLockConflict', () => {
+  it('returns undefined for a plain Error', async () => {
+    await expect(getLockConflict(new Error('boom'))).resolves.toBeUndefined()
+  })
+
+  it('returns undefined for a non-409 HTTPError', async () => {
+    const error = makeHttpError({ lockedTaskId: 5, bundledTasks: [] }, 403)
+    await expect(getLockConflict(error)).resolves.toBeUndefined()
+  })
+
+  it('returns undefined when the 409 body has no lockedTaskId', async () => {
+    const error = makeHttpError({ status: 'Conflict', message: 'nope' }, 409)
+    await expect(getLockConflict(error)).resolves.toBeUndefined()
+  })
+
+  it('parses a full lock conflict body', async () => {
+    const error = makeHttpError(
+      {
+        lockedTaskId: 42,
+        parentName: 'My Challenge',
+        bundledTasks: [43, 44],
+        startedAt: '2026-01-01T00:00:00.000Z',
+      },
+      409
+    )
+    await expect(getLockConflict(error)).resolves.toEqual({
+      lockedTaskId: 42,
+      parentName: 'My Challenge',
+      bundledTasks: [43, 44],
+      startedAt: '2026-01-01T00:00:00.000Z',
+    })
+  })
+
+  it('defaults optional fields when missing', async () => {
+    const error = makeHttpError({ lockedTaskId: 7 }, 409)
+    await expect(getLockConflict(error)).resolves.toEqual({
+      lockedTaskId: 7,
+      parentName: undefined,
+      bundledTasks: [],
+      startedAt: undefined,
+    })
+  })
+
+  it('returns undefined when the 409 response body is not valid JSON', async () => {
+    const response = new Response('not json', { status: 409 })
+    const request = new Request('http://example.test/api')
+    const error = new HTTPError(response, request, {} as NormalizedOptions)
+    await expect(getLockConflict(error)).resolves.toBeUndefined()
+  })
+})
diff --git a/src/lib/apiError.ts b/src/lib/apiError.ts
index 9ddcfb83c..1f159df16 100644
--- a/src/lib/apiError.ts
+++ b/src/lib/apiError.ts
@@ -14,3 +14,33 @@ export const getApiErrorMessage = async (error: unknown): Promise<string | undef
     return undefined
   }
 }
+
+/** Describes the lock a user already holds elsewhere, as returned on a 409 conflict. */
+export interface LockConflict {
+  lockedTaskId: number
+  parentName?: string
+  bundledTasks: number[]
+  startedAt?: string
+}
+
+/**
+ * A user may only hold one active edit lock at a time. Locking a task (or creating/updating
+ * a bundle) while already holding a different lock returns 409 with details of that lock, so
+ * the UI can offer to release it and retry. Returns undefined for any other kind of error.
+ */
+export const getLockConflict = async (error: unknown): Promise<LockConflict | undefined> => {
+  if (!(error instanceof HTTPError) || error.response.status !== 409) return undefined
+
+  try {
+    const body = await error.response.json()
+    if (typeof body?.lockedTaskId !== 'number') return undefined
+    return {
+      lockedTaskId: body.lockedTaskId,
+      parentName: typeof body.parentName === 'string' ? body.parentName : undefined,
+      bundledTasks: Array.isArray(body.bundledTasks) ? body.bundledTasks : [],
+      startedAt: typeof body.startedAt === 'string' ? body.startedAt : undefined,
+    }
+  } catch {
+    return undefined
+  }
+}
diff --git a/src/types/openApiTypes.ts b/src/types/openApiTypes.ts
index 2879246a3..c4ff94207 100644
--- a/src/types/openApiTypes.ts
+++ b/src/types/openApiTypes.ts
@@ -2496,7 +2496,10 @@ export interface paths {
     }
     /**
      * Start working on a Task (locks it for the user)
-     * @description Locks a Task based on the supplied ID in the URL.
+     * @description Locks a Task based on the supplied ID in the URL. A user may only hold one active
+     *     edit lock at a time - if the user already holds a lock on a different task, this
+     *     returns 409 Conflict describing that lock. The client should release that lock
+     *     (GET /task/:id/release) before retrying to lock this one.
      */
     get: operations['task_start_working_on_a_task_locks_it_for_the_user']
     put?: never
@@ -3113,26 +3116,6 @@ export interface paths {
     patch?: never
     trace?: never
   }
-  '/task/bundle/lock': {
-    parameters: {
-      query?: never
-      header?: never
-      path?: never
-      cookie?: never
-    }
-    get?: never
-    put?: never
-    /**
-     * Locks a bundle of tasks
-     * @description Attempts to lock a set of tasks. If successful, returns the tasks that were locked. If not successful, returns the tasks that were not locked.
-     */
-    post: operations['task_locks_a_bundle_of_tasks']
-    delete?: never
-    options?: never
-    head?: never
-    patch?: never
-    trace?: never
-  }
   '/task/bundle/unlock': {
     parameters: {
       query?: never
@@ -3144,7 +3127,10 @@ export interface paths {
     put?: never
     /**
      * Unlocks a bundle of tasks
-     * @description Unlocks the specified tasks in the bundle.
+     * @description Releases the calling user's lock covering any of the given task ids (bundles are
+     *     now locked as a single row on the bundle's primary task, so this releases that
+     *     covering lock if the user holds it - ids not currently locked by the user are
+     *     ignored rather than erroring).
      */
     post: operations['task_unlocks_a_bundle_of_tasks']
     delete?: never
@@ -3932,7 +3918,11 @@ export interface paths {
     put?: never
     /**
      * Create a task bundle
-     * @description Create a new task bundle with the task ids in the supplied JSON body.
+     * @description Create a new task bundle with the task ids in the supplied JSON body. The bundle's
+     *     primary task is locked for the calling user, with the other member task ids recorded
+     *     in that lock's bundledTasks. A user may only hold one active edit lock at a time - if
+     *     the user already holds a lock on a different task, this returns 409 Conflict describing
+     *     that lock. The client should release that lock before retrying.
      */
     post: operations['bundle_create_a_task_bundle']
     delete?: never
@@ -3976,7 +3966,9 @@ export interface paths {
     put?: never
     /**
      * Updates a Task Bundle
-     * @description Sets the bundle to the tasks provided, and unlock all tasks removed from current bundle
+     * @description Sets the bundle to the tasks provided, and unlock all tasks removed from current bundle.
+     *     Re-locks the bundle's primary task with the updated bundledTasks membership. Returns
+     *     409 Conflict if the user holds a lock on a different task.
      */
     post: operations['bundle_updates_a_task_bundle']
     delete?: never
@@ -4765,6 +4757,7 @@ export interface components {
       parentName: string
       /** Format: epoch */
       startedAt: number
+      bundledTasks: number[]
     }
     'org.maproulette.framework.model.CustomBasemap': {
       /** Format: int64 */
@@ -10807,6 +10800,13 @@ export interface operations {
         }
         content?: never
       }
+      /** @description The user already holds a lock on a different task */
+      409: {
+        headers: {
+          [name: string]: unknown
+        }
+        content?: never
+      }
     }
   }
   task_retrieve_any_change_xml_that_is_part_of_this_tasks: {
@@ -11989,38 +11989,6 @@ export interface operations {
       }
     }
   }
-  task_locks_a_bundle_of_tasks: {
-    parameters: {
-      query: {
-        taskIds: number[]
-      }
-      header?: never
-      path?: never
-      cookie?: never
-    }
-    /** @description A JSON array of task IDs to lock. */
-    requestBody: {
-      content: {
-        'application/json': number[]
-      }
-    }
-    responses: {
-      /** @description List of tasks that were locked or list of tasks that were not locked. Boolean indicates if the tasks were locked. */
-      200: {
-        headers: {
-          [name: string]: unknown
-        }
-        content?: never
-      }
-      /** @description The user is not authorized to make this request */
-      401: {
-        headers: {
-          [name: string]: unknown
-        }
-        content?: never
-      }
-    }
-  }
   task_unlocks_a_bundle_of_tasks: {
     parameters: {
       query: {
@@ -13601,14 +13569,18 @@ export interface operations {
         }
         content?: never
       }
+      /** @description The user already holds a lock on a different task */
+      409: {
+        headers: {
+          [name: string]: unknown
+        }
+        content?: never
+      }
     }
   }
   bundle_gets_a_task_bundle: {
     parameters: {
-      query?: {
-        /** @description The tasks in the bundle will be locked by the user. */
-        lockTasks?: boolean
-      }
+      query?: never
       header?: never
       path: {
         /** @description The id of the Task Bundle */
@@ -13700,6 +13672,13 @@ export interface operations {
         }
         content?: never
       }
+      /** @description The user already holds a lock on a different task */
+      409: {
+        headers: {
+          [name: string]: unknown
+        }
+        content?: never
+      }
     }
   }
   bundle_unbundles_tasks_from_task_bundle: {

From 1e2552553ddcd7ceb82d65ae19870673e24948b2 Mon Sep 17 00:00:00 2001
From: Collin Beczak <ctbeczak08@gmail.com>
Date: Wed, 5 Aug 2026 18:09:16 -0500
Subject: [PATCH 2/6] fix user interactions and add more web socket

---
 src/api/task/single.ts                        |  21 ++-
 .../Map/TaskMarkers/SpiderMarkers.tsx         |  25 +++-
 .../Map/TaskMarkers/clusterLayers.ts          |  23 +++
 .../Map/TaskMarkers/createMarkerIcons.ts      |   6 +-
 .../Pages/TaskEditPage/TaskInfoHeader.tsx     |  10 +-
 src/components/Pages/TaskEditPage/TaskMap.tsx |  55 ++++---
 .../TaskMap/useLassoBundleSync.ts             |  17 ++-
 .../TaskMap/useStyledClusteredData.ts         |  10 +-
 .../contexts/LockConflictDialog.tsx           |  88 ++++++++++++
 .../contexts/TaskBundleContext.tsx            | 118 ++++++++++++---
 .../TaskEditPage/contexts/TaskContext.tsx     | 136 ++++++++++++++----
 .../TaskEditPage/contexts/TaskMapContext.tsx  |   6 +
 src/components/Pages/TaskEditPage/index.tsx   |  33 -----
 .../TaskInfoPanel/TaskInfoDrawer.tsx          |   9 +-
 .../TaskInfoPanel/TaskTab/BundleTaskList.tsx  |  24 +---
 .../TaskInfoPanel/TaskTab/TaskTab.tsx         |   2 -
 src/hooks/useWebSocketEvents.ts               |  80 ++++++++++-
 src/i18n/messages/en-US.json                  |  10 ++
 src/lib/apiError.ts                           |  53 +++++--
 src/types/Task.ts                             |   5 +-
 src/types/WebSocket.ts                        |  22 +++
 21 files changed, 600 insertions(+), 153 deletions(-)
 create mode 100644 src/components/Pages/TaskEditPage/contexts/LockConflictDialog.tsx

diff --git a/src/api/task/single.ts b/src/api/task/single.ts
index f4aec03d9..0bf1accc5 100644
--- a/src/api/task/single.ts
+++ b/src/api/task/single.ts
@@ -57,7 +57,7 @@ export const taskSingle = {
     const queryClient = useQueryClient()
     return useMutation({
       mutationFn: (taskId: number) =>
-        apiRequest.get(`api/v2/task/${taskId}/start`).json<TaskGetResponse>(),
+        apiRequest.get(`api/v2/task/${taskId}/start`).json<TaskStartResponse>(),
       onSuccess: (lockedTask, taskId) => {
         queryClient.setQueryData<TaskGetResponse>(['task', taskId], lockedTask)
         queryClient.invalidateQueries({ queryKey: ['task', 'history', taskId] })
@@ -87,6 +87,25 @@ export const taskSingle = {
     })
   },
 
+  useLockTaskBundle: () => {
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: ({ taskId, taskIds }: { taskId: number; taskIds: number[] }) => {
+        const searchParams = new URLSearchParams()
+        taskIds.forEach((id) => searchParams.append('taskIds', String(id)))
+        return apiRequest
+          .put(`api/v2/task/${taskId}/lockBundle`, { searchParams })
+          .json<{ lockPrimaryTaskId: number; lockBundledTasks: number[] }>()
+      },
+      onError: (error, variables) => {
+        logger.error('Failed to update bundle lock', { error, variables })
+      },
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ['task', 'inBounds'] })
+      },
+    })
+  },
+
   useSkipTask: () => {
     const queryClient = useQueryClient()
     return useMutation({
diff --git a/src/components/Map/TaskMarkers/SpiderMarkers.tsx b/src/components/Map/TaskMarkers/SpiderMarkers.tsx
index 1ee489556..eb99a3632 100644
--- a/src/components/Map/TaskMarkers/SpiderMarkers.tsx
+++ b/src/components/Map/TaskMarkers/SpiderMarkers.tsx
@@ -25,6 +25,7 @@ interface SpiderMarkersProps {
   selectedTaskId?: number | null
   activeTaskId?: number | null
   lassoSelectedTaskIds?: Set<number>
+  hoveredTaskId?: number | null
 }
 
 /**
@@ -38,6 +39,7 @@ export const SpiderMarkers = ({
   selectedTaskId,
   activeTaskId,
   lassoSelectedTaskIds = new Set(),
+  hoveredTaskId,
 }: SpiderMarkersProps) => {
   const SPIDER_SOURCE_ID = 'spider-lines'
   const SPIDER_LINES_OUTLINE_ID = 'spider-lines-outline'
@@ -56,6 +58,7 @@ export const SpiderMarkers = ({
         const isSelected = marker.id === selectedTaskId
         const isActive = marker.id === activeTaskId
         const isLassoSelected = lassoSelectedTaskIds.has(marker.id)
+        const isHovered = marker.id === hoveredTaskId
         const typeKey = (marker as TaskMarker & { typeKey?: TaskTypeKey | null }).typeKey ?? null
 
         return {
@@ -69,6 +72,7 @@ export const SpiderMarkers = ({
             isSelected,
             isActive,
             isLassoSelected,
+            isHovered,
             isSpidered: true,
             ...(typeKey ? { typeKey } : {}),
           },
@@ -92,6 +96,7 @@ export const SpiderMarkers = ({
     selectedTaskId,
     activeTaskId,
     lassoSelectedTaskIds,
+    hoveredTaskId,
   ])
 
   const spiderLinesGeoJSON = useMemo(() => {
@@ -216,6 +221,16 @@ export const SpiderMarkers = ({
             'icon-image': [
               'case',
 
+              ['get', 'isHovered'],
+              [
+                'concat',
+                'marker-pin-',
+                ['to-string', ['get', 'status']],
+                '-',
+                ['to-string', ['coalesce', ['get', 'priority'], 1]],
+                '-hovered',
+              ],
+
               ['get', 'isPrimary'],
               [
                 'concat',
@@ -340,7 +355,13 @@ export const SpiderMarkers = ({
             'icon-size': [
               'case',
 
-              ['any', ['get', 'isHighlighted'], ['get', 'isActive'], ['get', 'isSelected']],
+              [
+                'any',
+                ['get', 'isHighlighted'],
+                ['get', 'isActive'],
+                ['get', 'isSelected'],
+                ['get', 'isHovered'],
+              ],
               1.4,
 
               1.0,
@@ -350,6 +371,8 @@ export const SpiderMarkers = ({
             'icon-ignore-placement': true,
             'symbol-sort-key': [
               'case',
+              ['get', 'isHovered'],
+              1300,
               ['get', 'isPrimary'],
               1200,
               ['all', ['get', 'isHighlighted'], ['get', 'isActive']],
diff --git a/src/components/Map/TaskMarkers/clusterLayers.ts b/src/components/Map/TaskMarkers/clusterLayers.ts
index 7f5399731..cd8a498d2 100644
--- a/src/components/Map/TaskMarkers/clusterLayers.ts
+++ b/src/components/Map/TaskMarkers/clusterLayers.ts
@@ -96,6 +96,26 @@ export const unclusteredPointLayer: LayerProps = {
     'icon-image': [
       'case',
 
+      ['==', ['get', 'isHovered'], true],
+      [
+        'case',
+        ['==', ['get', 'isOverlapping'], true],
+        [
+          'case',
+          ['>', ['get', 'overlapTaskCount'], 20],
+          'marker-overlap-many-hovered',
+          ['concat', 'marker-overlap-', ['to-string', ['get', 'overlapTaskCount']], '-hovered'],
+        ],
+        [
+          'concat',
+          'marker-pin-',
+          ['to-string', ['get', 'status']],
+          '-',
+          ['to-string', ['coalesce', ['get', 'priority'], 1]],
+          '-hovered',
+        ],
+      ],
+
       ['==', ['get', 'isOverlapping'], true],
       [
         'case',
@@ -267,6 +287,7 @@ export const unclusteredPointLayer: LayerProps = {
         ['==', ['get', 'isHighlighted'], true],
         ['==', ['get', 'isActive'], true],
         ['==', ['get', 'isSelected'], true],
+        ['==', ['get', 'isHovered'], true],
       ],
       1.4,
 
@@ -281,6 +302,8 @@ export const unclusteredPointLayer: LayerProps = {
     'icon-opacity': [
       'case',
 
+      ['==', ['get', 'isHovered'], true],
+      1,
       ['==', ['get', 'isPrimary'], true],
       1,
       ['==', ['get', 'isHighlighted'], true],
diff --git a/src/components/Map/TaskMarkers/createMarkerIcons.ts b/src/components/Map/TaskMarkers/createMarkerIcons.ts
index 44dc19a4e..ac237ff78 100644
--- a/src/components/Map/TaskMarkers/createMarkerIcons.ts
+++ b/src/components/Map/TaskMarkers/createMarkerIcons.ts
@@ -188,7 +188,7 @@ export const createMarkerIcons = (
 
         createMarkerIcon(status, color, priority, '#f59e0b')
 
-        createMarkerIcon(status, color, priority, '#22c55e', 'hovered')
+        createMarkerIcon(status, color, priority, '#3b82f6', 'hovered')
 
         createMarkerIcon(status, color, priority, '#eab308')
 
@@ -312,7 +312,7 @@ export const createMarkerIcons = (
 
       createOverlapIcon(taskCount, `marker-overlap-${taskCount}-primary`, '#f59e0b', 3)
 
-      createOverlapIcon(taskCount, `marker-overlap-${taskCount}-hovered`, '#22c55e', 3)
+      createOverlapIcon(taskCount, `marker-overlap-${taskCount}-hovered`, '#3b82f6', 3)
 
       createOverlapIcon(taskCount, `marker-overlap-${taskCount}-lasso`, '#eab308', 3)
 
@@ -342,7 +342,7 @@ export const createMarkerIcons = (
     createOverlapIcon('20+', 'marker-overlap-many-selected', '#8b5cf6', 3)
     createOverlapIcon('20+', 'marker-overlap-many-bundled', '#22c55e', 3)
     createOverlapIcon('20+', 'marker-overlap-many-primary', '#f59e0b', 3)
-    createOverlapIcon('20+', 'marker-overlap-many-hovered', '#22c55e', 3)
+    createOverlapIcon('20+', 'marker-overlap-many-hovered', '#3b82f6', 3)
     createOverlapIcon('20+', 'marker-overlap-many-lasso', '#eab308', 3)
     createDualBorderOverlapIcon('20+', 'marker-overlap-many-bundled-selected', '#8b5cf6', '#22c55e')
     createDualBorderOverlapIcon('20+', 'marker-overlap-many-primary-selected', '#8b5cf6', '#f59e0b')
diff --git a/src/components/Pages/TaskEditPage/TaskInfoHeader.tsx b/src/components/Pages/TaskEditPage/TaskInfoHeader.tsx
index a99e1a1d9..a5cc5ac48 100644
--- a/src/components/Pages/TaskEditPage/TaskInfoHeader.tsx
+++ b/src/components/Pages/TaskEditPage/TaskInfoHeader.tsx
@@ -3,7 +3,10 @@ import bbox from '@turf/bbox'
 import { ExternalLink, Eye, EyeOff, Share2, Star, X, ZoomIn } from 'lucide-react'
 import { api } from '@/api'
 import { useChallengeContext } from '@/components/Pages/TaskEditPage/contexts/ChallengeContext'
-import { EDITABLE_STATUSES } from '@/components/Pages/TaskEditPage/contexts/TaskContext'
+import {
+  EDITABLE_STATUSES,
+  useTaskContext,
+} from '@/components/Pages/TaskEditPage/contexts/TaskContext'
 import { useTaskMapContext } from '@/components/Pages/TaskEditPage/contexts/TaskMapContext'
 import { SharePopoverContent } from '@/components/shared/ShareLink/SharePopoverContent'
 import {
@@ -51,6 +54,7 @@ export const TaskInfoHeader = ({
   const { isAuthenticated } = useAuthContext()
   const { map, markersHidden, setMarkersHidden } = useTaskMapContext()
   const { data: project } = api.project.getProject(challenge?.parent)
+  const { task: contextTask } = useTaskContext()
 
   const status = task.status ?? 0
   const statusLabel = getStatusLabel(t, status) || t('common.unknown', undefined, 'Unknown')
@@ -175,7 +179,9 @@ export const TaskInfoHeader = ({
                 </a>
               </Button>
             )}
-            {EDITABLE_STATUSES.includes(status) && <LockButton compact />}
+            {task.id === contextTask.id && EDITABLE_STATUSES.includes(status) && (
+              <LockButton compact />
+            )}
             {onClose && (
               <Button
                 variant="ghost"
diff --git a/src/components/Pages/TaskEditPage/TaskMap.tsx b/src/components/Pages/TaskEditPage/TaskMap.tsx
index f7888547f..c7323e504 100644
--- a/src/components/Pages/TaskEditPage/TaskMap.tsx
+++ b/src/components/Pages/TaskEditPage/TaskMap.tsx
@@ -55,13 +55,19 @@ export const TaskMap = () => {
   const exploreSourceId = useId()
   const exploreCirclesLayerId = useId()
   const { bundleEditsDisabled, activeBundle } = useTaskBundleContext()
-  const { task } = useTaskContext()
+  const { task, isLocked } = useTaskContext()
   const { openIdEditor, idEditorMounted, idUnsavedCount, activeView, idViewportRef } =
     useEditorContext()
   const prevActiveView = useRef(activeView)
   const isEditableStatus = EDITABLE_STATUSES.includes(task.status ?? 0)
-  const { selectedMarker, markersHidden, activeTaskId, drawingMode, selectedTaskIds } =
-    useTaskMapContext()
+  const {
+    selectedMarker,
+    markersHidden,
+    activeTaskId,
+    drawingMode,
+    selectedTaskIds,
+    hoveredBundleTaskId,
+  } = useTaskMapContext()
 
   const {
     mapRef,
@@ -186,6 +192,7 @@ export const TaskMap = () => {
               selectedTaskId={selectedMarker?.id ?? null}
               activeTaskId={activeTaskId}
               lassoSelectedTaskIds={selectedTaskIds}
+              hoveredTaskId={hoveredBundleTaskId}
             />
           )}
 
@@ -204,26 +211,28 @@ export const TaskMap = () => {
       {/* Top-left inline controls: cluster toggle + multi-task panel + iD Editor */}
       <div className="absolute top-2 left-2 z-10 flex items-start gap-2">
         <ClusterToggle clusteringEnabled={isClustered} onToggle={setIsClustered} inline />
-        {!bundleEditsDisabled && isEditableStatus && <MultiTaskPanel />}
-        <button
-          type="button"
-          onClick={openIdEditor}
-          className="relative flex h-10 items-center gap-1.5 rounded-lg bg-zinc-800/90 px-3 font-medium text-sm text-white shadow-md transition-colors hover:bg-zinc-700"
-          title={t('taskEditPage.taskMap.editInId', undefined, 'Edit in iD (inline)')}
-        >
-          <OsmIcon className="h-4 w-4" />
-          {t('taskEditPage.taskMap.editInIdShort', undefined, 'Edit in iD')}
-          {idEditorMounted && (
-            <span className="flex items-center gap-1">
-              <span className="h-2 w-2 rounded-full bg-green-400" />
-              {idUnsavedCount > 0 && (
-                <span className="rounded-full bg-yellow-500 px-1.5 py-0.5 font-bold text-[10px] text-white leading-none">
-                  {idUnsavedCount}
-                </span>
-              )}
-            </span>
-          )}
-        </button>
+        {isLocked && !bundleEditsDisabled && isEditableStatus && <MultiTaskPanel />}
+        {isLocked && (
+          <button
+            type="button"
+            onClick={openIdEditor}
+            className="relative flex h-10 items-center gap-1.5 rounded-lg bg-zinc-800/90 px-3 font-medium text-sm text-white shadow-md transition-colors hover:bg-zinc-700"
+            title={t('taskEditPage.taskMap.editInId', undefined, 'Edit in iD (inline)')}
+          >
+            <OsmIcon className="h-4 w-4" />
+            {t('taskEditPage.taskMap.editInIdShort', undefined, 'Edit in iD')}
+            {idEditorMounted && (
+              <span className="flex items-center gap-1">
+                <span className="h-2 w-2 rounded-full bg-green-400" />
+                {idUnsavedCount > 0 && (
+                  <span className="rounded-full bg-yellow-500 px-1.5 py-0.5 font-bold text-[10px] text-white leading-none">
+                    {idUnsavedCount}
+                  </span>
+                )}
+              </span>
+            )}
+          </button>
+        )}
       </div>
 
       {/* Drawing mode indicator */}
diff --git a/src/components/Pages/TaskEditPage/TaskMap/useLassoBundleSync.ts b/src/components/Pages/TaskEditPage/TaskMap/useLassoBundleSync.ts
index 51945c354..25d7d4bba 100644
--- a/src/components/Pages/TaskEditPage/TaskMap/useLassoBundleSync.ts
+++ b/src/components/Pages/TaskEditPage/TaskMap/useLassoBundleSync.ts
@@ -13,7 +13,7 @@ import {
 
 export const useLassoBundleSync = () => {
   const { selectedTaskIds, clearSelection } = useTaskMapContext()
-  const { activeBundle, setActiveBundle } = useTaskBundleContext()
+  const { activeBundle, setActiveBundle, persistBundle } = useTaskBundleContext()
   const { task } = useTaskContext()
   const primaryTaskId = task.id
   const { data: primaryTaskData } = api.task.getTask(primaryTaskId)
@@ -22,37 +22,42 @@ export const useLassoBundleSync = () => {
     if (selectedTaskIds.size === 0) return
 
     const selectedArray = Array.from(selectedTaskIds)
+    let newBundle: TaskBundle | null = null
 
     if (!activeBundle) {
       // Create new bundle with primary task and selected tasks
       const newTaskIds = [primaryTaskId, ...selectedArray].slice(0, MAX_SELECTED_TASKS)
-      const newBundle: TaskBundle = {
+      newBundle = {
         bundleId: PENDING_BUNDLE_ID,
         taskIds: newTaskIds,
         tasks: primaryTaskData ? [primaryTaskData] : [],
         name: 'Bundle (pending)',
       }
-      setActiveBundle(newBundle)
     } else {
       // Add to existing bundle
       const newTaskIds = selectedArray.filter((id) => !activeBundle.taskIds.includes(id))
-
       if (newTaskIds.length > 0) {
         const updatedTaskIds = [...activeBundle.taskIds, ...newTaskIds].slice(0, MAX_SELECTED_TASKS)
-        setActiveBundle({
+        newBundle = {
           ...activeBundle,
           taskIds: updatedTaskIds,
           tasks: activeBundle.tasks,
-        })
+        }
       }
     }
 
+    if (newBundle) {
+      setActiveBundle(newBundle)
+      persistBundle(newBundle)
+    }
+
     // Clear selection after adding to bundle
     clearSelection()
   }, [
     selectedTaskIds,
     activeBundle,
     setActiveBundle,
+    persistBundle,
     clearSelection,
     primaryTaskId,
     primaryTaskData,
diff --git a/src/components/Pages/TaskEditPage/TaskMap/useStyledClusteredData.ts b/src/components/Pages/TaskEditPage/TaskMap/useStyledClusteredData.ts
index 60934ecac..57c9c3623 100644
--- a/src/components/Pages/TaskEditPage/TaskMap/useStyledClusteredData.ts
+++ b/src/components/Pages/TaskEditPage/TaskMap/useStyledClusteredData.ts
@@ -2,11 +2,11 @@ import { useMemo } from 'react'
 import { useTaskMapContext } from '../contexts/TaskMapContext'
 
 export const useStyledClusteredData = (clusteredGeoJSONData: GeoJSON.FeatureCollection) => {
-  const { selectedTaskIds, activeTaskId } = useTaskMapContext()
+  const { selectedTaskIds, activeTaskId, hoveredBundleTaskId } = useTaskMapContext()
 
   // Reason: applies styling to clustered GeoJSON data
   return useMemo((): GeoJSON.FeatureCollection => {
-    if (selectedTaskIds.size === 0 && activeTaskId == null) {
+    if (selectedTaskIds.size === 0 && activeTaskId == null && hoveredBundleTaskId == null) {
       return clusteredGeoJSONData
     }
 
@@ -23,7 +23,8 @@ export const useStyledClusteredData = (clusteredGeoJSONData: GeoJSON.FeatureColl
         }
         const isLassoSelected = selectedTaskIds.has(taskId)
         const isActive = taskId === activeTaskId
-        if (!isLassoSelected && !isActive) {
+        const isHovered = taskId === hoveredBundleTaskId
+        if (!isLassoSelected && !isActive && !isHovered) {
           return feature
         }
         return {
@@ -32,9 +33,10 @@ export const useStyledClusteredData = (clusteredGeoJSONData: GeoJSON.FeatureColl
             ...feature.properties,
             ...(isLassoSelected && { isLassoSelected: true }),
             ...(isActive && { isActive: true }),
+            ...(isHovered && { isHovered: true }),
           },
         }
       }),
     }
-  }, [clusteredGeoJSONData, selectedTaskIds, activeTaskId])
+  }, [clusteredGeoJSONData, selectedTaskIds, activeTaskId, hoveredBundleTaskId])
 }
diff --git a/src/components/Pages/TaskEditPage/contexts/LockConflictDialog.tsx b/src/components/Pages/TaskEditPage/contexts/LockConflictDialog.tsx
new file mode 100644
index 000000000..b650ed338
--- /dev/null
+++ b/src/components/Pages/TaskEditPage/contexts/LockConflictDialog.tsx
@@ -0,0 +1,88 @@
+import { useNavigate } from '@tanstack/react-router'
+import { LockOpen } from 'lucide-react'
+import { Button } from '@/components/ui/Button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/Dialog'
+import { useIntl } from '@/i18n'
+import type { LockConflictInfo } from '@/lib/apiError'
+import { formatTimeAgo } from '@/lib/date'
+
+interface Props {
+  conflict: LockConflictInfo | null
+  onOpenChange: (open: boolean) => void
+  onConfirm: () => void
+  busy?: boolean
+}
+
+export const LockConflictDialog = ({ conflict, onOpenChange, onConfirm, busy }: Props) => {
+  const { t, locale } = useIntl()
+  const navigate = useNavigate()
+
+  const handleGoBack = () => {
+    if (!conflict) return
+    onOpenChange(false)
+    navigate({ to: '/tasks/$taskId', params: { taskId: String(conflict.lockedTaskId) } })
+  }
+
+  return (
+    <Dialog open={conflict != null} onOpenChange={onOpenChange}>
+      <DialogContent size="lg">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <LockOpen className="size-5 text-amber-500" aria-hidden="true" />
+            {t(
+              'taskEditPage.lockConflictDialog.title',
+              undefined,
+              'You already have a task locked'
+            )}
+          </DialogTitle>
+          <DialogDescription>
+            {conflict?.parentName
+              ? t(
+                  'taskEditPage.lockConflictDialog.descriptionWithChallenge',
+                  {
+                    taskId: conflict.lockedTaskId,
+                    challengeName: conflict.parentName,
+                  },
+                  'You still hold the lock on task #{taskId} in "{challengeName}". Release it to lock this task instead.'
+                )
+              : t(
+                  'taskEditPage.lockConflictDialog.description',
+                  { taskId: conflict?.lockedTaskId ?? 0 },
+                  'You still hold the lock on task #{taskId}. Release it to lock this task instead.'
+                )}
+            {conflict?.startedAt &&
+              ` (${t(
+                'taskEditPage.lockConflictDialog.lockedSince',
+                { time: formatTimeAgo(new Date(conflict.startedAt), locale) },
+                'locked {time}'
+              )})`}
+          </DialogDescription>
+        </DialogHeader>
+        <DialogFooter className="sm:flex-wrap sm:gap-2 sm:space-x-0">
+          <Button variant="outline" onClick={handleGoBack} disabled={busy}>
+            {t('taskEditPage.lockConflictDialog.goBack', undefined, 'Go back to previous task')}
+          </Button>
+          <Button variant="outline" onClick={() => onOpenChange(false)} disabled={busy}>
+            {t('taskEditPage.lockConflictDialog.inspect', undefined, 'Inspect this task')}
+          </Button>
+          <Button onClick={onConfirm} disabled={busy}>
+            {busy
+              ? t('taskEditPage.lockConflictDialog.switching', undefined, 'Switching…')
+              : t(
+                  'taskEditPage.lockConflictDialog.confirm',
+                  undefined,
+                  'Release other lock & continue'
+                )}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/src/components/Pages/TaskEditPage/contexts/TaskBundleContext.tsx b/src/components/Pages/TaskEditPage/contexts/TaskBundleContext.tsx
index 923660534..e3806226f 100644
--- a/src/components/Pages/TaskEditPage/contexts/TaskBundleContext.tsx
+++ b/src/components/Pages/TaskEditPage/contexts/TaskBundleContext.tsx
@@ -13,6 +13,13 @@ import type { Task, TaskMarker } from '@/types/Task'
 /** Sentinel for a locally-built bundle that hasn't been persisted yet. */
 export const PENDING_BUNDLE_ID = 0
 
+/** Canonicalizes a set of task IDs for order-independent comparison. */
+const sortedIdKey = (ids: number[]) =>
+  ids
+    .slice()
+    .sort((a, b) => a - b)
+    .join(',')
+
 export interface TaskBundle {
   bundleId: number
   taskIds: number[]
@@ -24,7 +31,6 @@ export interface TaskBundleContextType {
   activeBundle: TaskBundle | null
   setActiveBundle: Dispatch<SetStateAction<TaskBundle | null>>
   initialBundle: TaskBundle | null
-  setInitialBundle: Dispatch<SetStateAction<TaskBundle | null>>
   showBundleOnly: boolean
   setShowBundleOnly: Dispatch<SetStateAction<boolean>>
   bundleEditsDisabled: boolean
@@ -56,19 +62,23 @@ export interface TaskBundleContextType {
   canAddSelectedMarkerToBundle: boolean
   handleAddToBundle: () => void
   handleRemoveFromBundle: () => void
+  /** Updates the live lock to cover the given bundle's member tasks (or none, if null) -
+   * for edits made outside these handlers, e.g. the lasso-select workflow in
+   * useLassoBundleSync. Never touches the persisted task_bundles record; that only
+   * happens when the task is actually submitted (see TaskActionModal). */
+  persistBundle: (nextBundle: TaskBundle | null) => void
 }
 
 const TaskBundleContext = createContext<TaskBundleContextType | undefined>(undefined)
 
 export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
   const { t } = useIntl()
-  const { task } = useTaskContext()
+  const { task, isLocked, lockedTasks } = useTaskContext()
   const { user } = useAuthContext()
   const { selectedMarker, setSelectedMarker, setActiveTaskId, emptyClickCount } =
     useTaskMapContext()
 
   const [activeBundle, setActiveBundle] = useState<TaskBundle | null>(null)
-  const [initialBundle, setInitialBundle] = useState<TaskBundle | null>(null)
   const [showBundleOnly, setShowBundleOnly] = useState(false)
   const [bundleEditsDisabled, setBundleEditsDisabled] = useState(false)
   const [bundlingDisabledReason, setBundlingDisabledReason] = useState<string | null>(null)
@@ -76,6 +86,34 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
   const [showDeleteDialog, setShowDeleteDialog] = useState(false)
   const [drawerTaskId, setDrawerTaskId] = useState<number | null>(null)
 
+  const lockBundleMutation = api.task.useLockTaskBundle()
+
+  const persistBundle = useCallback(
+    (nextBundle: TaskBundle | null) => {
+      const memberTaskIds = nextBundle?.taskIds.filter((id) => id !== task.id) ?? []
+      lockBundleMutation.mutate({ taskId: task.id, taskIds: memberTaskIds })
+    },
+    [task.id, lockBundleMutation.mutate]
+  )
+
+  const { data: dbBundle } = api.taskBundle.getTaskBundle(task.bundleId ?? 0)
+  const dbBundleTaskIds = useMemo(
+    () => dbBundle?.taskIds.filter((id) => id !== task.id) ?? [],
+    [dbBundle, task.id]
+  )
+
+  const initialBundle: TaskBundle | null = useMemo(
+    () =>
+      dbBundleTaskIds.length === 0
+        ? null
+        : {
+            bundleId: dbBundle?.bundleId ?? PENDING_BUNDLE_ID,
+            taskIds: [task.id, ...dbBundleTaskIds],
+            name: 'Bundle',
+          },
+    [dbBundleTaskIds, task.id, dbBundle?.bundleId]
+  )
+
   // Reason: stable references returned from context — consumers use these as event handler dependencies
   const clearBundle = useCallback(() => {
     setActiveBundle(null)
@@ -92,12 +130,15 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
 
   const handleClearBundle = useCallback(() => {
     if (!activeBundle) return
+    // Release the lock's bundled tasks too - otherwise other tabs would still see them as
+    // locked/bundled even though this tab has moved on to just the primary.
+    persistBundle(null)
     clearBundle()
     toast.success(
       t('taskEditPage.taskBundle.clearedSuccess', undefined, 'Now working on only the primary task')
     )
     setShowDeleteDialog(false)
-  }, [activeBundle, clearBundle])
+  }, [activeBundle, clearBundle, persistBundle])
 
   const bundleTaskIds = activeBundle?.taskIds ?? [task.id]
   const isNonBundleSelection = selectedMarker !== null && !bundleTaskIds.includes(selectedMarker.id)
@@ -115,10 +156,16 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
   const { data: fetchedTask } = api.task.getTask(viewedTaskId !== task.id ? viewedTaskId : 0)
   const viewedTask: Task = viewedTaskId === task.id ? task : (fetchedTask ?? task)
 
-  // Fetch bundle data for the viewed task (if it has a bundleId)
-  const { data: viewedTaskBundle } = api.taskBundle.getTaskBundle(viewedTask.bundleId ?? 0)
-  const viewedTaskBundleTaskIds =
-    viewedTaskBundle?.taskIds.filter((id) => id !== viewedTaskId) ?? []
+  const confirmedBundleTaskIds = useMemo(
+    () => (isLocked ? lockedTasks : dbBundleTaskIds),
+    [isLocked, lockedTasks, dbBundleTaskIds]
+  )
+
+  const viewedTaskBundleTaskIds = useMemo(() => {
+    const isViewedTaskConfirmed =
+      viewedTaskId === task.id || confirmedBundleTaskIds.includes(viewedTaskId)
+    return isViewedTaskConfirmed ? confirmedBundleTaskIds.filter((id) => id !== viewedTaskId) : []
+  }, [viewedTaskId, task.id, confirmedBundleTaskIds])
 
   const isViewedTaskInBundle = activeBundle?.taskIds.includes(viewedTaskId) ?? false
 
@@ -170,33 +217,57 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
     }
   }, [emptyClickCount, setSelectedMarker])
 
+  useEffect(() => {
+    setActiveBundle(null)
+  }, [task.id])
+
+  useEffect(() => {
+    const confirmedKey = sortedIdKey(confirmedBundleTaskIds)
+    const activeKey = sortedIdKey(activeBundle?.taskIds.filter((id) => id !== task.id) ?? [])
+    if (confirmedKey === activeKey) return
+
+    if (confirmedBundleTaskIds.length === 0) {
+      setActiveBundle(null)
+      return
+    }
+
+    setActiveBundle({
+      bundleId: task.bundleId ?? PENDING_BUNDLE_ID,
+      taskIds: [task.id, ...confirmedBundleTaskIds],
+      name: 'Bundle',
+    })
+  }, [confirmedBundleTaskIds, task.id, task.bundleId])
+
   // Reason: stable references returned from context — consumers use these as event handler dependencies
   const handleAddToBundle = useCallback(() => {
     if (bundleEditsDisabled || !selectedMarker) return
 
+    let newBundle: TaskBundle
     if (!activeBundle) {
-      const newBundle = {
+      newBundle = {
         bundleId: PENDING_BUNDLE_ID,
         taskIds: [task.id, selectedMarker.id],
         tasks: [task],
         name: `Bundle (pending)`,
       }
       setActiveBundle(newBundle)
-      setInitialBundle(null)
     } else {
       if (activeBundle.taskIds.includes(selectedMarker.id)) return
-      setActiveBundle({
+      newBundle = {
         ...activeBundle,
         taskIds: [...activeBundle.taskIds, selectedMarker.id],
         tasks: activeBundle.tasks,
-      })
+      }
+      setActiveBundle(newBundle)
     }
 
+    persistBundle(newBundle)
+
     // Move the newly added task into the drawer as a bundle task
     const addedId = selectedMarker.id
     setSelectedMarker(null)
     setDrawerTaskId(addedId)
-  }, [bundleEditsDisabled, selectedMarker, activeBundle, task, setSelectedMarker])
+  }, [bundleEditsDisabled, selectedMarker, activeBundle, task, setSelectedMarker, persistBundle])
 
   const handleRemoveFromBundle = useCallback(() => {
     if (bundleEditsDisabled || !activeBundle) return
@@ -208,14 +279,16 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
     const updatedTaskIds = activeBundle.taskIds.filter((id) => id !== removedTaskId)
 
     if (updatedTaskIds.length <= 1) {
+      persistBundle(null)
       setActiveBundle(null)
-      setInitialBundle(null)
     } else {
-      setActiveBundle({
+      const newBundle: TaskBundle = {
         ...activeBundle,
         taskIds: updatedTaskIds,
         tasks: activeBundle.tasks,
-      })
+      }
+      setActiveBundle(newBundle)
+      persistBundle(newBundle)
     }
 
     // Show removed task as non-bundle selection in drawer.
@@ -229,7 +302,15 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
     }
     setSelectedMarker(removedTaskMarker)
     setDrawerTaskId(null)
-  }, [bundleEditsDisabled, activeBundle, viewedTaskId, task.id, viewedTask, setSelectedMarker])
+  }, [
+    bundleEditsDisabled,
+    activeBundle,
+    viewedTaskId,
+    task.id,
+    viewedTask,
+    setSelectedMarker,
+    persistBundle,
+  ])
 
   // Reason: context value must be stable to prevent all consumers from re-rendering
   const value: TaskBundleContextType = useMemo(
@@ -237,7 +318,6 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
       activeBundle,
       setActiveBundle,
       initialBundle,
-      setInitialBundle,
       showBundleOnly,
       setShowBundleOnly,
       bundleEditsDisabled,
@@ -261,6 +341,7 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
       canAddSelectedMarkerToBundle,
       handleAddToBundle,
       handleRemoveFromBundle,
+      persistBundle,
     }),
     [
       activeBundle,
@@ -282,6 +363,7 @@ export const TaskBundleProvider = ({ children }: { children: ReactNode }) => {
       canAddSelectedMarkerToBundle,
       handleAddToBundle,
       handleRemoveFromBundle,
+      persistBundle,
     ]
   )
 
diff --git a/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx b/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
index b17577461..4fc8fa3b0 100644
--- a/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
+++ b/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
@@ -1,11 +1,16 @@
 import { useLoaderData } from '@tanstack/react-router'
 import type { ReactNode } from 'react'
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react'
+import { toast } from 'sonner'
 import { api } from '@/api'
 import { useAuthContext } from '@/contexts/AuthContext'
-import { useLockConflict } from '@/hooks/useLockConflict'
+import { useWebSocketContext } from '@/contexts/WebSocketContext'
+import { useIntl } from '@/i18n'
+import { getLockConflictInfo, type LockConflictInfo } from '@/lib/apiError'
+import { logger } from '@/lib/logger'
 import type { Task } from '@/types/Task'
-import { LockConflictModal } from '../TaskActions/LockConflictModal'
+import type { TaskEventMessage, TasksEventMessage } from '@/types/WebSocket'
+import { LockConflictDialog } from './LockConflictDialog'
 
 // Statuses that allow editing: Created (0), Skipped (3), Too Hard/Can't Complete (6)
 export const EDITABLE_STATUSES = [0, 3, 6]
@@ -14,6 +19,7 @@ export interface TaskContextType {
   task: Task
   isLocked: boolean
   isLocking: boolean
+  lockedTasks: number[]
   lockTask: () => void
   unlockTask: () => void
 }
@@ -21,40 +27,57 @@ export interface TaskContextType {
 export const TaskContext = createContext<TaskContextType | undefined>(undefined)
 
 export const TaskProvider = ({ children }: { children: ReactNode }) => {
-  const { task, challenge } = useLoaderData({ from: '/_app/tasks/$taskId/' })
-  const { isAuthenticated } = useAuthContext()
+  const { task: loaderTask, challenge } = useLoaderData({ from: '/_app/tasks/$taskId/' })
+  const { data: liveTask } = api.task.getTask(loaderTask.id)
+  const task = liveTask ?? loaderTask
+  const { user, isAuthenticated } = useAuthContext()
+  const { lastMessage } = useWebSocketContext()
+  const { t } = useIntl()
   const lockTaskMutation = api.task.useLockTask()
   const unlockTaskMutation = api.task.useUnlockTask()
-  const lockConflict = useLockConflict()
   const hasAttemptedLock = useRef(false)
   const [isLocked, setIsLocked] = useState(false)
+  const [lockedTasks, setLockedTasks] = useState<number[]>([])
+  const [lockConflict, setLockConflict] = useState<LockConflictInfo | null>(null)
 
   const lockedTaskIdRef = useRef<number | null>(null)
 
-  useEffect(() => {
-    hasAttemptedLock.current = false
-    setIsLocked(false)
-  }, [task?.id])
-
-  // Shared by the auto-lock effect and the manual lockTask() call so both go through the
-  // same conflict handling: on a 409 (user already holds a different lock), the
-  // LockConflictModal is shown and this same taskId is retried if they confirm.
   const attemptLock = useCallback(
     (taskId: number) => {
       lockTaskMutation.mutate(taskId, {
-        onSuccess: () => {
+        onSuccess: (data) => {
           setIsLocked(true)
           lockedTaskIdRef.current = taskId
+          setLockedTasks(data.lockBundledTasks.filter((id) => id !== taskId))
         },
         onError: async (error) => {
-          const handled = await lockConflict.handleError(error, () => attemptLock(taskId))
-          if (!handled) setIsLocked(false)
+          setIsLocked(false)
+          const conflict = await getLockConflictInfo(error)
+          if (conflict) {
+            setLockConflict(conflict)
+            return
+          }
+          logger.error('Failed to lock task', { taskId, error })
+          toast.error(
+            t(
+              'taskEditPage.taskActions.lockButton.lockConflict',
+              undefined,
+              'This task is currently locked by another mapper. Try again later or pick a different task.'
+            )
+          )
         },
       })
     },
-    [lockTaskMutation, lockConflict]
+    [lockTaskMutation, t]
   )
 
+  useEffect(() => {
+    hasAttemptedLock.current = false
+    setIsLocked(false)
+    setLockedTasks([])
+    setLockConflict(null)
+  }, [task?.id])
+
   useEffect(() => {
     if (!task || !isAuthenticated || hasAttemptedLock.current) return
     if (!EDITABLE_STATUSES.includes(task.status ?? 0)) return
@@ -72,7 +95,51 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
         lockedTaskIdRef.current = null
       }
     }
-  }, [task?.id, unlockTaskMutation])
+  }, [unlockTaskMutation.mutate])
+
+  useEffect(() => {
+    if (!task || !lastMessage || typeof lastMessage !== 'object') return
+    const message = lastMessage as Partial<TaskEventMessage>
+    if (message.messageType !== 'task-released' && message.messageType !== 'task-claimed') return
+    if (message.data?.task?.id !== task.id) return
+
+    if (message.messageType === 'task-released') {
+      setIsLocked(false)
+      setLockedTasks([])
+      lockedTaskIdRef.current = null
+      return
+    }
+
+    const claimedByMe = message.data.byUser == null || message.data.byUser.userId === user?.id
+    setIsLocked(claimedByMe)
+    if (!claimedByMe) {
+      lockedTaskIdRef.current = null
+    }
+  }, [lastMessage, task, user?.id])
+
+  useEffect(() => {
+    if (!task || !lastMessage || typeof lastMessage !== 'object') return
+    const message = lastMessage as Partial<TasksEventMessage>
+    if (message.messageType !== 'tasks-claimed' && message.messageType !== 'tasks-released') return
+    const tasks = message.data?.tasks
+    if (!tasks?.some((t) => t.id === task.id)) return
+    const byMe = message.data?.byUser == null || message.data.byUser.userId === user?.id
+    if (!byMe) return
+
+    if (message.messageType === 'tasks-released') {
+      setLockedTasks([])
+      return
+    }
+
+    setLockedTasks(tasks.map((t) => t.id).filter((id) => id !== task.id))
+    setIsLocked(true)
+  }, [lastMessage, task, user?.id])
+
+  useEffect(() => {
+    if (isLocked && lockConflict) {
+      setLockConflict(null)
+    }
+  }, [isLocked, lockConflict])
 
   const lockTask = useCallback(() => {
     if (!task || challenge?.paused) return
@@ -82,29 +149,48 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
   const unlockTask = useCallback(() => {
     if (!task) return
     unlockTaskMutation.mutate(task.id, {
-      onSuccess: () => setIsLocked(false),
+      onSuccess: () => {
+        setIsLocked(false)
+        setLockedTasks([])
+        if (lockedTaskIdRef.current === task.id) {
+          lockedTaskIdRef.current = null
+        }
+      },
     })
   }, [task, unlockTaskMutation])
 
+  const handleConfirmSwitchLock = useCallback(() => {
+    if (!task || !lockConflict) return
+    unlockTaskMutation.mutate(lockConflict.lockedTaskId, {
+      onSettled: () => {
+        setLockConflict(null)
+        attemptLock(task.id)
+      },
+    })
+  }, [task, lockConflict, unlockTaskMutation, attemptLock])
+
   const value: TaskContextType = useMemo(
     () => ({
       task,
       isLocked,
       isLocking: lockTaskMutation.isPending,
+      lockedTasks,
       lockTask,
       unlockTask,
     }),
-    [task, isLocked, lockTaskMutation.isPending, lockTask, unlockTask]
+    [task, isLocked, lockTaskMutation.isPending, lockedTasks, lockTask, unlockTask]
   )
 
   return (
     <TaskContext.Provider value={value}>
       {children}
-      <LockConflictModal
-        conflict={lockConflict.conflict}
-        onConfirm={lockConflict.confirm}
-        onCancel={lockConflict.cancel}
-        busy={lockConflict.isReleasing}
+      <LockConflictDialog
+        conflict={lockConflict}
+        onOpenChange={(open) => {
+          if (!open) setLockConflict(null)
+        }}
+        onConfirm={handleConfirmSwitchLock}
+        busy={unlockTaskMutation.isPending}
       />
     </TaskContext.Provider>
   )
diff --git a/src/components/Pages/TaskEditPage/contexts/TaskMapContext.tsx b/src/components/Pages/TaskEditPage/contexts/TaskMapContext.tsx
index 5015ef90f..0c97488be 100644
--- a/src/components/Pages/TaskEditPage/contexts/TaskMapContext.tsx
+++ b/src/components/Pages/TaskEditPage/contexts/TaskMapContext.tsx
@@ -15,6 +15,8 @@ export interface TaskMapContextType {
   setSelectedMarker: (marker: TaskMarker | null) => void
   markersHidden: boolean
   setMarkersHidden: (hidden: boolean) => void
+  hoveredBundleTaskId: number | null
+  setHoveredBundleTaskId: (taskId: number | null) => void
   activeTaskId: number | null
   setActiveTaskId: (taskId: number | null) => void
   emptyClickCount: number
@@ -44,6 +46,7 @@ export const TaskMapProvider = ({ children }: { children: ReactNode }) => {
   const [mapLoaded, setMapLoaded] = useState(false)
   const [selectedMarker, setSelectedMarker] = useState<TaskMarker | null>(null)
   const [markersHidden, setMarkersHidden] = useState(false)
+  const [hoveredBundleTaskId, setHoveredBundleTaskId] = useState<number | null>(null)
   const [activeTaskId, setActiveTaskId] = useState<number | null>(null)
   const [emptyClickCount, setEmptyClickCount] = useState(0)
 
@@ -94,6 +97,8 @@ export const TaskMapProvider = ({ children }: { children: ReactNode }) => {
       setSelectedMarker,
       markersHidden,
       setMarkersHidden,
+      hoveredBundleTaskId,
+      setHoveredBundleTaskId,
       activeTaskId,
       setActiveTaskId,
       emptyClickCount,
@@ -115,6 +120,7 @@ export const TaskMapProvider = ({ children }: { children: ReactNode }) => {
       mapLoaded,
       selectedMarker,
       markersHidden,
+      hoveredBundleTaskId,
       activeTaskId,
       emptyClickCount,
       drawingMode,
diff --git a/src/components/Pages/TaskEditPage/index.tsx b/src/components/Pages/TaskEditPage/index.tsx
index e70a7c37d..2f337576f 100644
--- a/src/components/Pages/TaskEditPage/index.tsx
+++ b/src/components/Pages/TaskEditPage/index.tsx
@@ -1,9 +1,5 @@
 import { useLoaderData } from '@tanstack/react-router'
-import { useEffect } from 'react'
-import { api } from '@/api'
 import { KeyboardShortcutsProvider } from '@/components/Pages/TaskEditPage/contexts/KeyboardShortcutsContext'
-import { useTaskBundleContext } from '@/components/Pages/TaskEditPage/contexts/TaskBundleContext'
-import { useTaskContext } from '@/components/Pages/TaskEditPage/contexts/TaskContext'
 import { TaskMap } from '@/components/Pages/TaskEditPage/TaskMap'
 import {
   DrawerPortalProvider,
@@ -21,37 +17,8 @@ const viewPanelClass = (isActive: boolean) =>
   isActive ? 'absolute inset-0 z-[1]' : 'invisible absolute inset-0 z-0 pointer-events-none'
 
 const TaskContent = () => {
-  const { task } = useTaskContext()
-  const { setActiveBundle, setInitialBundle } = useTaskBundleContext()
   const { activeView, idEditorMounted, showMap } = useEditorContext()
 
-  // Fetch bundle if task belongs to one
-  const { data: bundleData } = api.taskBundle.getTaskBundle(task.bundleId ?? 0)
-
-  // Clear stale bundle immediately when navigating to a different task,
-  // before the new bundle data has loaded
-  useEffect(() => {
-    setActiveBundle(null)
-    setInitialBundle(null)
-  }, [task.id, setActiveBundle, setInitialBundle])
-
-  // Set active bundle and initial bundle when bundle data is loaded,
-  // or clear when navigating to a task without a bundle
-  useEffect(() => {
-    if (bundleData && task.bundleId) {
-      const bundle = {
-        bundleId: bundleData.bundleId,
-        taskIds: bundleData.taskIds,
-        name: `Bundle #${bundleData.bundleId}`,
-      }
-      setActiveBundle(bundle)
-      setInitialBundle(bundle)
-    } else if (!task.bundleId) {
-      setActiveBundle(null)
-      setInitialBundle(null)
-    }
-  }, [bundleData, task.bundleId, setActiveBundle, setInitialBundle])
-
   return (
     <DrawerPortalProvider>
       <div className="h-full px-4 md:overflow-hidden">
diff --git a/src/components/TaskInfoPanel/TaskInfoDrawer.tsx b/src/components/TaskInfoPanel/TaskInfoDrawer.tsx
index 31ff5349f..c800702ec 100644
--- a/src/components/TaskInfoPanel/TaskInfoDrawer.tsx
+++ b/src/components/TaskInfoPanel/TaskInfoDrawer.tsx
@@ -84,7 +84,14 @@ export const TaskInfoDrawer = ({ selectedTask, onClose, mapRef }: TaskInfoDrawer
   const taskContextValue = useMemo(
     () =>
       task
-        ? { task, isLocked: false, isLocking: false, lockTask: noop, unlockTask: noop }
+        ? {
+            task,
+            isLocked: false,
+            isLocking: false,
+            lockedTasks: [],
+            lockTask: noop,
+            unlockTask: noop,
+          }
         : undefined,
     [task]
   )
diff --git a/src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx b/src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx
index b1837c6f1..d672dc634 100644
--- a/src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx
+++ b/src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx
@@ -1,26 +1,22 @@
 import { MousePointerClick, Package, Star } from 'lucide-react'
 import { useEditorContext } from '@/components/Pages/TaskEditPage/contexts/EditorContext'
+import { useTaskMapContext } from '@/components/Pages/TaskEditPage/contexts/TaskMapContext'
 import { useIntl } from '@/i18n'
 
 interface BundleTaskListProps {
   taskIds: number[]
   primaryTaskId: number
   onOpenBundleTask?: (taskId: number) => void
-  /** Task ID whose drawer is currently open — keeps highlight active */
-  activeDrawerTaskId?: number | null
 }
 
-export const BundleTaskList = ({
-  taskIds,
-  primaryTaskId,
-  onOpenBundleTask,
-  activeDrawerTaskId,
-}: BundleTaskListProps) => {
+export const BundleTaskList = ({ taskIds, primaryTaskId, onOpenBundleTask }: BundleTaskListProps) => {
   const { t } = useIntl()
   const { highlightIdEntityRef, taskToOsmIdRef, selectIdEntitiesRef, activeView } =
     useEditorContext()
+  const { setHoveredBundleTaskId } = useTaskMapContext()
 
   const highlightTask = (taskId: number | null) => {
+    setHoveredBundleTaskId(taskId)
     if (activeView !== 'id') return
     const osmId = taskId != null ? (taskToOsmIdRef.current?.[taskId] ?? null) : null
     highlightIdEntityRef.current?.(osmId)
@@ -46,15 +42,9 @@ export const BundleTaskList = ({
 
   const highlightHandlers = (taskId: number) => ({
     onMouseEnter: () => highlightTask(taskId),
-    onMouseLeave: () => {
-      if (activeDrawerTaskId === taskId) return
-      highlightTask(null)
-    },
+    onMouseLeave: () => highlightTask(null),
     onFocus: () => highlightTask(taskId),
-    onBlur: () => {
-      if (activeDrawerTaskId === taskId) return
-      highlightTask(null)
-    },
+    onBlur: () => highlightTask(null),
   })
 
   if (taskIds.length === 0) return null
@@ -93,7 +83,7 @@ export const BundleTaskList = ({
               <button
                 type="button"
                 onClick={() => {
-                  highlightTask(taskId)
+                  if (isPrimary) return
                   onOpenBundleTask?.(taskId)
                 }}
                 {...highlightHandlers(taskId)}
diff --git a/src/components/TaskInfoPanel/TaskTab/TaskTab.tsx b/src/components/TaskInfoPanel/TaskTab/TaskTab.tsx
index db0ee554d..d1c153ab9 100644
--- a/src/components/TaskInfoPanel/TaskTab/TaskTab.tsx
+++ b/src/components/TaskInfoPanel/TaskTab/TaskTab.tsx
@@ -22,7 +22,6 @@ export const TaskTab = ({ task }: TaskTabProps) => {
     canAddSelectedMarkerToBundle,
     handleAddToBundle,
     handleRemoveFromBundle,
-    drawerTaskId,
     setDrawerTaskId,
   } = useTaskBundleContext()
 
@@ -45,7 +44,6 @@ export const TaskTab = ({ task }: TaskTabProps) => {
         taskIds={allBundleTaskIds}
         primaryTaskId={primaryTask.id}
         onOpenBundleTask={isPrimaryTask ? setDrawerTaskId : undefined}
-        activeDrawerTaskId={isPrimaryTask ? drawerTaskId : undefined}
       />
 
       <BundleStateIndicator
diff --git a/src/hooks/useWebSocketEvents.ts b/src/hooks/useWebSocketEvents.ts
index 3641531db..61d5c8d94 100644
--- a/src/hooks/useWebSocketEvents.ts
+++ b/src/hooks/useWebSocketEvents.ts
@@ -11,6 +11,7 @@ import type {
   NotificationNewMessage,
   ReviewEventMessage,
   TaskEventMessage,
+  TasksEventMessage,
   TeamUpdateMessage,
   WebSocketMessageTypes,
 } from '@/types/WebSocket'
@@ -27,6 +28,12 @@ const isTaskEvent = (m: WebSocketMessageTypes): m is TaskEventMessage =>
   m.messageType === 'task-completed' ||
   m.messageType === 'task-update'
 
+const isTasksEvent = (m: WebSocketMessageTypes): m is TasksEventMessage =>
+  m.messageType === 'tasks-claimed' ||
+  m.messageType === 'tasks-released' ||
+  m.messageType === 'tasks-update' ||
+  m.messageType === 'tasks-completed'
+
 const isReviewEvent = (m: WebSocketMessageTypes): m is ReviewEventMessage =>
   m.messageType === 'review-new' ||
   m.messageType === 'review-claimed' ||
@@ -35,6 +42,13 @@ const isReviewEvent = (m: WebSocketMessageTypes): m is ReviewEventMessage =>
 const isTeamUpdate = (m: WebSocketMessageTypes): m is TeamUpdateMessage =>
   m.messageType === 'team-update'
 
+// Invalidate the caches that back the current user's own profile/score display -
+// shared by every message type that can affect them (achievement, task/tasks completed).
+const invalidateOwnUserQueries = (queryClient: ReturnType<typeof useQueryClient>, userId: number) => {
+  queryClient.invalidateQueries({ queryKey: ['user', 'whoami'] })
+  queryClient.invalidateQueries({ queryKey: ['user', userId] })
+}
+
 /**
  * Centralized dispatcher for WebSocket events coming from the backend.
  * Mount once at the app root (AppLayout).
@@ -62,8 +76,7 @@ export const useWebSocketEvents = () => {
           lastMessage.data.achievement.forEach((id) => {
             enqueue({ kind: 'achievement', achievementId: id })
           })
-          queryClient.invalidateQueries({ queryKey: ['user', 'whoami'] })
-          queryClient.invalidateQueries({ queryKey: ['user', user.id] })
+          invalidateOwnUserQueries(queryClient, user.id)
         }
         return
       }
@@ -113,8 +126,67 @@ export const useWebSocketEvents = () => {
           user &&
           lastMessage.data.byUser?.userId === user.id
         ) {
-          queryClient.invalidateQueries({ queryKey: ['user', 'whoami'] })
-          queryClient.invalidateQueries({ queryKey: ['user', user.id] })
+          invalidateOwnUserQueries(queryClient, user.id)
+        }
+        return
+      }
+
+      if (isTasksEvent(lastMessage)) {
+        const messageType = lastMessage.messageType
+        const invalidatedChallenges = new Set<number>()
+        const historyTaskIds = new Set<number>()
+
+        lastMessage.data.tasks.forEach((bundledTask) => {
+          const challengeId = lastMessage.data.challenge?.id ?? bundledTask.parent
+          const newStatus = bundledTask.status ?? undefined
+
+          const cachedTask = queryClient.getQueryData<TaskGetResponse>(['task', bundledTask.id])
+          const oldStatus = cachedTask?.status ?? undefined
+          if (cachedTask) {
+            queryClient.setQueryData<TaskGetResponse>(['task', bundledTask.id], {
+              ...cachedTask,
+              status: newStatus ?? cachedTask.status,
+              bundleId: bundledTask.bundleId ?? cachedTask.bundleId,
+              isBundlePrimary: bundledTask.isBundlePrimary ?? cachedTask.isBundlePrimary,
+            })
+          }
+
+          const markerPatch: Parameters<typeof patchChallengeTaskMarker>[3] = {}
+          if (newStatus !== undefined) markerPatch.status = newStatus
+          if (messageType === 'tasks-claimed') {
+            markerPatch.lockedBy = lastMessage.data.byUser?.userId ?? null
+          } else if (messageType === 'tasks-released') {
+            markerPatch.lockedBy = null
+          }
+          if (Object.keys(markerPatch).length > 0) {
+            patchChallengeTaskMarker(queryClient, challengeId, bundledTask.id, markerPatch)
+          }
+
+          historyTaskIds.add(bundledTask.id)
+
+          const statusChanged = newStatus !== undefined && newStatus !== oldStatus
+          if (statusChanged && !invalidatedChallenges.has(challengeId)) {
+            invalidatedChallenges.add(challengeId)
+            invalidateChallengeAggregates(queryClient, challengeId)
+          }
+        })
+
+        if (historyTaskIds.size > 0) {
+          // One cache scan for the whole bundle instead of one invalidateQueries call per task.
+          queryClient.invalidateQueries({
+            predicate: (query) =>
+              query.queryKey[0] === 'task' &&
+              query.queryKey[1] === 'history' &&
+              historyTaskIds.has(query.queryKey[2] as number),
+          })
+        }
+
+        if (
+          messageType === 'tasks-completed' &&
+          user &&
+          lastMessage.data.byUser?.userId === user.id
+        ) {
+          invalidateOwnUserQueries(queryClient, user.id)
         }
         return
       }
diff --git a/src/i18n/messages/en-US.json b/src/i18n/messages/en-US.json
index 5d0348fcf..4f01f6674 100644
--- a/src/i18n/messages/en-US.json
+++ b/src/i18n/messages/en-US.json
@@ -379,6 +379,8 @@
   "dashboard.common.failedToLoad": "Failed to load",
   "dashboard.contributions.empty.description": "Start mapping to track progress",
   "dashboard.contributions.empty.title": "No contributions",
+  "dashboard.contributions.inProgress": "In Progress",
+  "dashboard.contributions.inProgressLabel": "Task #{taskId} in progress",
   "dashboard.contributions.statusSetLabel": "Set Status on Task as {statusLabel}",
   "dashboard.contributions.title": "Contributions",
   "dashboard.contributions.unknownChallenge": "Challenge {parentId}",
@@ -1023,6 +1025,14 @@
   "taskEditPage.keyboardShortcuts.pressSuffix": "anytime to show this dialog",
   "taskEditPage.keyboardShortcuts.showShortcuts": "Show keyboard shortcuts",
   "taskEditPage.keyboardShortcuts.title": "Keyboard Shortcuts",
+  "taskEditPage.lockConflictDialog.confirm": "Release other lock & continue",
+  "taskEditPage.lockConflictDialog.description": "You still hold the lock on task #{taskId}. Release it to lock this task instead.",
+  "taskEditPage.lockConflictDialog.descriptionWithChallenge": "You still hold the lock on task #{taskId} in \"{challengeName}\". Release it to lock this task instead.",
+  "taskEditPage.lockConflictDialog.goBack": "Go back to previous task",
+  "taskEditPage.lockConflictDialog.inspect": "Inspect this task",
+  "taskEditPage.lockConflictDialog.lockedSince": "locked {time}",
+  "taskEditPage.lockConflictDialog.switching": "Switching…",
+  "taskEditPage.lockConflictDialog.title": "You already have a task locked",
   "taskEditPage.osmData.areaTooLarge": "Area too large",
   "taskEditPage.osmData.areaTooLargeDescription": "Please zoom in further to view OSM features. The selected area exceeds the maximum allowed size.",
   "taskEditPage.osmData.fetchError": "Failed to fetch OSM data",
diff --git a/src/lib/apiError.ts b/src/lib/apiError.ts
index 1f159df16..2e7663177 100644
--- a/src/lib/apiError.ts
+++ b/src/lib/apiError.ts
@@ -15,20 +15,24 @@ export const getApiErrorMessage = async (error: unknown): Promise<string | undef
   }
 }
 
-/** Describes the lock a user already holds elsewhere, as returned on a 409 conflict. */
-export interface LockConflict {
+/** The lock a user already holds elsewhere, as returned by a 409 lock-conflict response. */
+export interface LockConflictInfo {
   lockedTaskId: number
-  parentName?: string
-  bundledTasks: number[]
-  startedAt?: string
+  parentName?: string | null
+  bundledTasks?: number[] | null
+  startedAt?: string | null
+  message?: string
 }
 
 /**
- * A user may only hold one active edit lock at a time. Locking a task (or creating/updating
- * a bundle) while already holding a different lock returns 409 with details of that lock, so
- * the UI can offer to release it and retry. Returns undefined for any other kind of error.
+ * Extracts the `{status: "Conflict", lockedTaskId, ...}` body the backend sends when a
+ * task/bundle lock request is rejected because the user already holds a different lock
+ * (one active edit lock per user). Returns undefined for any other error, including a
+ * plain 409 without a `lockedTaskId`.
  */
-export const getLockConflict = async (error: unknown): Promise<LockConflict | undefined> => {
+export const getLockConflictInfo = async (
+  error: unknown
+): Promise<LockConflictInfo | undefined> => {
   if (!(error instanceof HTTPError) || error.response.status !== 409) return undefined
 
   try {
@@ -36,11 +40,36 @@ export const getLockConflict = async (error: unknown): Promise<LockConflict | un
     if (typeof body?.lockedTaskId !== 'number') return undefined
     return {
       lockedTaskId: body.lockedTaskId,
-      parentName: typeof body.parentName === 'string' ? body.parentName : undefined,
-      bundledTasks: Array.isArray(body.bundledTasks) ? body.bundledTasks : [],
-      startedAt: typeof body.startedAt === 'string' ? body.startedAt : undefined,
+      parentName: body.parentName ?? null,
+      bundledTasks: body.bundledTasks ?? null,
+      startedAt: body.startedAt ?? null,
+      message: typeof body.message === 'string' ? body.message : undefined,
     }
   } catch {
     return undefined
   }
 }
+
+/** Describes the lock a user already holds elsewhere, as returned on a 409 conflict. */
+export interface LockConflict {
+  lockedTaskId: number
+  parentName?: string
+  bundledTasks: number[]
+  startedAt?: string
+}
+
+/**
+ * A user may only hold one active edit lock at a time. Locking a task (or creating/updating
+ * a bundle) while already holding a different lock returns 409 with details of that lock, so
+ * the UI can offer to release it and retry. Returns undefined for any other kind of error.
+ */
+export const getLockConflict = async (error: unknown): Promise<LockConflict | undefined> => {
+  const info = await getLockConflictInfo(error)
+  if (!info) return undefined
+  return {
+    lockedTaskId: info.lockedTaskId,
+    parentName: info.parentName ?? undefined,
+    bundledTasks: info.bundledTasks ?? [],
+    startedAt: info.startedAt ?? undefined,
+  }
+}
diff --git a/src/types/Task.ts b/src/types/Task.ts
index f7898498e..9aad6b176 100644
--- a/src/types/Task.ts
+++ b/src/types/Task.ts
@@ -1,7 +1,10 @@
 import type { components, operations, paths } from './openApiTypes'
 
 /* Responses */
-export type TaskStartResponse = Task
+export type TaskStartResponse = Task & {
+  lockPrimaryTaskId: number
+  lockBundledTasks: number[]
+}
 export type TaskGetResponse = Task
 export type TaskMarkersResponse =
   paths['/taskMarkers']['get']['responses']['200']['content']['application/json']
diff --git a/src/types/WebSocket.ts b/src/types/WebSocket.ts
index 92ca97b0f..60b4f1acb 100644
--- a/src/types/WebSocket.ts
+++ b/src/types/WebSocket.ts
@@ -63,6 +63,27 @@ export interface TaskEventMessage extends WebSocketMessage {
   data: TaskAction
 }
 
+export interface BundleTaskInfo {
+  id: number
+  parent: number
+  status?: number | null
+  name?: string
+  bundleId?: number | null
+  isBundlePrimary?: boolean | null
+}
+
+export interface TasksAction {
+  tasks: BundleTaskInfo[]
+  challenge: ChallengeSummary | null
+  project: ProjectSummary | null
+  byUser: UserSummary | null
+}
+
+export interface TasksEventMessage extends WebSocketMessage {
+  messageType: 'tasks-claimed' | 'tasks-released' | 'tasks-update' | 'tasks-completed'
+  data: TasksAction
+}
+
 export interface ReviewData {
   taskWithReview: {
     task: { id: number; parent: number; status?: number | null }
@@ -95,6 +116,7 @@ export type WebSocketMessageTypes =
   | NotificationNewMessage
   | AchievementAwardedMessage
   | TaskEventMessage
+  | TasksEventMessage
   | ReviewEventMessage
   | TeamUpdateMessage
   | FollowUpdateMessage

From dfda0878d1728819ad600e0949730a0ea87ab021 Mon Sep 17 00:00:00 2001
From: Collin Beczak <ctbeczak08@gmail.com>
Date: Wed, 5 Aug 2026 18:10:59 -0500
Subject: [PATCH 3/6] format

---
 src/api/task/single.ts                                  | 4 +++-
 src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx | 6 +++++-
 src/hooks/useWebSocketEvents.ts                         | 5 ++++-
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/api/task/single.ts b/src/api/task/single.ts
index 0bf1accc5..6de01727b 100644
--- a/src/api/task/single.ts
+++ b/src/api/task/single.ts
@@ -92,7 +92,9 @@ export const taskSingle = {
     return useMutation({
       mutationFn: ({ taskId, taskIds }: { taskId: number; taskIds: number[] }) => {
         const searchParams = new URLSearchParams()
-        taskIds.forEach((id) => searchParams.append('taskIds', String(id)))
+        taskIds.forEach((id) => {
+          searchParams.append('taskIds', String(id))
+        })
         return apiRequest
           .put(`api/v2/task/${taskId}/lockBundle`, { searchParams })
           .json<{ lockPrimaryTaskId: number; lockBundledTasks: number[] }>()
diff --git a/src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx b/src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx
index d672dc634..4abb76e2a 100644
--- a/src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx
+++ b/src/components/TaskInfoPanel/TaskTab/BundleTaskList.tsx
@@ -9,7 +9,11 @@ interface BundleTaskListProps {
   onOpenBundleTask?: (taskId: number) => void
 }
 
-export const BundleTaskList = ({ taskIds, primaryTaskId, onOpenBundleTask }: BundleTaskListProps) => {
+export const BundleTaskList = ({
+  taskIds,
+  primaryTaskId,
+  onOpenBundleTask,
+}: BundleTaskListProps) => {
   const { t } = useIntl()
   const { highlightIdEntityRef, taskToOsmIdRef, selectIdEntitiesRef, activeView } =
     useEditorContext()
diff --git a/src/hooks/useWebSocketEvents.ts b/src/hooks/useWebSocketEvents.ts
index 61d5c8d94..4e7b07eb1 100644
--- a/src/hooks/useWebSocketEvents.ts
+++ b/src/hooks/useWebSocketEvents.ts
@@ -44,7 +44,10 @@ const isTeamUpdate = (m: WebSocketMessageTypes): m is TeamUpdateMessage =>
 
 // Invalidate the caches that back the current user's own profile/score display -
 // shared by every message type that can affect them (achievement, task/tasks completed).
-const invalidateOwnUserQueries = (queryClient: ReturnType<typeof useQueryClient>, userId: number) => {
+const invalidateOwnUserQueries = (
+  queryClient: ReturnType<typeof useQueryClient>,
+  userId: number
+) => {
   queryClient.invalidateQueries({ queryKey: ['user', 'whoami'] })
   queryClient.invalidateQueries({ queryKey: ['user', userId] })
 }

From c45133f6106a32d82e72341924400b778a41c206 Mon Sep 17 00:00:00 2001
From: Collin Beczak <ctbeczak08@gmail.com>
Date: Wed, 5 Aug 2026 18:44:49 -0500
Subject: [PATCH 4/6] fix coverage

---
 src/api/task/single.test.ts          |  50 ++++++
 src/hooks/useWebSocketEvents.test.ts | 250 +++++++++++++++++++++++++++
 src/lib/apiError.test.ts             |  18 +-
 3 files changed, 317 insertions(+), 1 deletion(-)

diff --git a/src/api/task/single.test.ts b/src/api/task/single.test.ts
index 3bb1b0e75..f19fe79f9 100644
--- a/src/api/task/single.test.ts
+++ b/src/api/task/single.test.ts
@@ -256,6 +256,56 @@ describe('taskSingle.useUnlockTask', () => {
   })
 })
 
+describe('taskSingle.useLockTaskBundle', () => {
+  it('PUTs the bundled task ids as repeated taskIds params and invalidates inBounds tasks', async () => {
+    const fetchMock = stubFetch(
+      new Response(JSON.stringify({ lockPrimaryTaskId: 1, lockBundledTasks: [2, 3] }), {
+        status: 200,
+      })
+    )
+    const queryClient = createTestQueryClient()
+    const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries')
+
+    const { result } = renderHook(() => taskSingle.useLockTaskBundle(), {
+      wrapper: queryClientWrapper(queryClient),
+    })
+
+    result.current.mutate({ taskId: 1, taskIds: [2, 3] })
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+
+    expect(result.current.data).toEqual({ lockPrimaryTaskId: 1, lockBundledTasks: [2, 3] })
+    const [request] = fetchMock.mock.calls[0] as [Request]
+    expect(request.method).toBe('PUT')
+    const url = new URL(request.url)
+    expect(url.pathname).toBe('/api/v2/task/1/lockBundle')
+    expect(url.searchParams.getAll('taskIds')).toEqual(['2', '3'])
+    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: ['task', 'inBounds'] })
+  })
+
+  it('logs and swallows a failed bundle lock update', async () => {
+    const { logger } = await import('@/lib/logger')
+    const loggerErrorSpy = vi.spyOn(logger, 'error').mockImplementation(() => {})
+    stubFetch(new Response('conflict', { status: 409 }))
+    const queryClient = createTestQueryClient()
+
+    const { result } = renderHook(() => taskSingle.useLockTaskBundle(), {
+      wrapper: queryClientWrapper(queryClient),
+    })
+
+    result.current.mutate({ taskId: 1, taskIds: [2] })
+
+    await waitFor(() => expect(result.current.isError).toBe(true))
+
+    expect(loggerErrorSpy).toHaveBeenCalledWith(
+      'Failed to update bundle lock',
+      expect.objectContaining({ variables: { taskId: 1, taskIds: [2] } })
+    )
+
+    loggerErrorSpy.mockRestore()
+  })
+})
+
 describe('taskSingle.useSkipTask', () => {
   it('marks a cached task skipped, invalidates aggregates when the status actually changed, and patches the marker', async () => {
     stubFetch(new Response('', { status: 200 }))
diff --git a/src/hooks/useWebSocketEvents.test.ts b/src/hooks/useWebSocketEvents.test.ts
index f8d313157..566e07a4f 100644
--- a/src/hooks/useWebSocketEvents.test.ts
+++ b/src/hooks/useWebSocketEvents.test.ts
@@ -14,6 +14,7 @@ import type {
   NotificationNewMessage,
   ReviewEventMessage,
   TaskEventMessage,
+  TasksEventMessage,
   TeamUpdateMessage,
   WebSocketMessageTypes,
 } from '@/types/WebSocket'
@@ -346,6 +347,255 @@ describe('useWebSocketEvents', () => {
     })
   })
 
+  describe('tasks events (bundled)', () => {
+    const tasksEvent = (overrides: Partial<TasksEventMessage['data']> = {}): TasksEventMessage => ({
+      messageType: 'tasks-claimed',
+      data: {
+        tasks: [{ id: 1, parent: 10, status: 2 }],
+        challenge: null,
+        project: null,
+        byUser: { userId: 5, osmId: 1, displayName: 'x', avatarURL: '' },
+        ...overrides,
+      },
+    })
+
+    it('patches each cached bundled task, locks its marker, invalidates history for all of them, and dedupes aggregate invalidation within the same challenge', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket(
+        tasksEvent({
+          tasks: [
+            { id: 1, parent: 10, status: 2, bundleId: 99, isBundlePrimary: true },
+            { id: 2, parent: 10, status: 2 },
+          ],
+        })
+      )
+      const queryClient = createTestQueryClient()
+      queryClient.setQueryData<TaskGetResponse>(['task', 1], {
+        id: 1,
+        parent: 10,
+        status: 0,
+      } as TaskGetResponse)
+      queryClient.setQueryData<TaskGetResponse>(['task', 2], {
+        id: 2,
+        parent: 10,
+        status: 0,
+        bundleId: 50,
+      } as TaskGetResponse)
+      const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries')
+
+      mount(queryClient)
+
+      expect(queryClient.getQueryData<TaskGetResponse>(['task', 1])).toEqual({
+        id: 1,
+        parent: 10,
+        status: 2,
+        bundleId: 99,
+        isBundlePrimary: true,
+      })
+      // Task 2's message has no bundleId/isBundlePrimary, so the cached values carry over.
+      expect(queryClient.getQueryData<TaskGetResponse>(['task', 2])).toEqual({
+        id: 2,
+        parent: 10,
+        status: 2,
+        bundleId: 50,
+        isBundlePrimary: undefined,
+      })
+
+      expect(patchChallengeTaskMarker).toHaveBeenCalledWith(queryClient, 10, 1, {
+        status: 2,
+        lockedBy: 5,
+      })
+      expect(patchChallengeTaskMarker).toHaveBeenCalledWith(queryClient, 10, 2, {
+        status: 2,
+        lockedBy: 5,
+      })
+
+      const historyCall = invalidateSpy.mock.calls.find(
+        ([arg]) => typeof (arg as { predicate?: unknown })?.predicate === 'function'
+      )
+      expect(historyCall).toBeDefined()
+      const predicate = (
+        historyCall?.[0] as unknown as { predicate: (q: { queryKey: unknown[] }) => boolean }
+      ).predicate
+      expect(predicate({ queryKey: ['task', 'history', 1] })).toBe(true)
+      expect(predicate({ queryKey: ['task', 'history', 2] })).toBe(true)
+      expect(predicate({ queryKey: ['task', 'history', 3] })).toBe(false)
+      expect(predicate({ queryKey: ['challenge', 10] })).toBe(false)
+
+      // Both tasks changed status within the same challenge; only invalidated once.
+      expect(invalidateChallengeAggregates).toHaveBeenCalledTimes(1)
+      expect(invalidateChallengeAggregates).toHaveBeenCalledWith(queryClient, 10)
+    })
+
+    it('clears lockedBy on tasks-released and skips aggregate invalidation when status is unchanged', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket({
+        ...tasksEvent({ tasks: [{ id: 1, parent: 10, status: 2 }] }),
+        messageType: 'tasks-released',
+      })
+      const queryClient = createTestQueryClient()
+      queryClient.setQueryData<TaskGetResponse>(['task', 1], {
+        id: 1,
+        parent: 10,
+        status: 2,
+      } as TaskGetResponse)
+
+      mount(queryClient)
+
+      expect(patchChallengeTaskMarker).toHaveBeenCalledWith(
+        queryClient,
+        10,
+        1,
+        expect.objectContaining({ lockedBy: null })
+      )
+      expect(invalidateChallengeAggregates).not.toHaveBeenCalled()
+    })
+
+    it('skips the cache patch for a bundled task with no cache entry', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket(tasksEvent({ tasks: [{ id: 42, parent: 10, status: 2 }] }))
+      const queryClient = createTestQueryClient()
+
+      mount(queryClient)
+
+      expect(queryClient.getQueryData(['task', 42])).toBeUndefined()
+      expect(patchChallengeTaskMarker).toHaveBeenCalledWith(queryClient, 10, 42, {
+        status: 2,
+        lockedBy: 5,
+      })
+    })
+
+    it('leaves lockedBy unset on tasks-update, only patching status', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket({
+        ...tasksEvent({ tasks: [{ id: 1, parent: 10, status: 2 }] }),
+        messageType: 'tasks-update',
+      })
+      const queryClient = createTestQueryClient()
+
+      mount(queryClient)
+
+      expect(patchChallengeTaskMarker).toHaveBeenCalledWith(queryClient, 10, 1, { status: 2 })
+    })
+
+    it('falls back to the cached status and skips the status key on the marker patch when the bundled task has no status', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket(tasksEvent({ tasks: [{ id: 1, parent: 10, status: undefined }] }))
+      const queryClient = createTestQueryClient()
+      queryClient.setQueryData<TaskGetResponse>(['task', 1], {
+        id: 1,
+        parent: 10,
+        status: 5,
+      } as TaskGetResponse)
+
+      mount(queryClient)
+
+      expect(queryClient.getQueryData<TaskGetResponse>(['task', 1])?.status).toBe(5)
+      expect(patchChallengeTaskMarker).toHaveBeenCalledWith(
+        queryClient,
+        10,
+        1,
+        expect.not.objectContaining({ status: expect.anything() })
+      )
+    })
+
+    it('locks with null when tasks-claimed has no byUser', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket(tasksEvent({ tasks: [{ id: 1, parent: 10, status: 2 }], byUser: null }))
+      const queryClient = createTestQueryClient()
+
+      mount(queryClient)
+
+      expect(patchChallengeTaskMarker).toHaveBeenCalledWith(
+        queryClient,
+        10,
+        1,
+        expect.objectContaining({ lockedBy: null })
+      )
+    })
+
+    it('skips the marker patch entirely when tasks-update leaves an empty patch', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket({
+        ...tasksEvent({ tasks: [{ id: 1, parent: 10, status: undefined }] }),
+        messageType: 'tasks-update',
+      })
+      const queryClient = createTestQueryClient()
+
+      mount(queryClient)
+
+      expect(patchChallengeTaskMarker).not.toHaveBeenCalled()
+    })
+
+    it('skips the history invalidation and marker patches entirely for an empty bundle', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket(tasksEvent({ tasks: [] }))
+      const queryClient = createTestQueryClient()
+      const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries')
+
+      mount(queryClient)
+
+      expect(patchChallengeTaskMarker).not.toHaveBeenCalled()
+      expect(invalidateSpy).not.toHaveBeenCalled()
+    })
+
+    it('derives the challenge id from data.challenge, taking priority over each task.parent', () => {
+      mockAuth(undefined)
+      mockCongratulate()
+      mockWebSocket(
+        tasksEvent({
+          challenge: { id: 77, parentId: 1, name: 'c', enabled: true },
+          tasks: [{ id: 1, parent: 10, status: 2 }],
+        })
+      )
+      const queryClient = createTestQueryClient()
+
+      mount(queryClient)
+
+      expect(patchChallengeTaskMarker).toHaveBeenCalledWith(queryClient, 77, 1, expect.anything())
+      expect(invalidateChallengeAggregates).toHaveBeenCalledWith(queryClient, 77)
+    })
+
+    it('invalidates own user queries on tasks-completed by the current user, not by another user', () => {
+      mockAuth(fakeUser(5))
+      mockCongratulate()
+      mockWebSocket({
+        ...tasksEvent({ byUser: { userId: 5, osmId: 1, displayName: 'x', avatarURL: '' } }),
+        messageType: 'tasks-completed',
+      })
+      const queryClient = createTestQueryClient()
+      const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries')
+
+      mount(queryClient)
+
+      expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: ['user', 'whoami'] })
+      expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: ['user', 5] })
+    })
+
+    it('does not invalidate own user queries on tasks-completed by a different user', () => {
+      mockAuth(fakeUser(5))
+      mockCongratulate()
+      mockWebSocket({
+        ...tasksEvent({ byUser: { userId: 99, osmId: 1, displayName: 'x', avatarURL: '' } }),
+        messageType: 'tasks-completed',
+      })
+      const queryClient = createTestQueryClient()
+      const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries')
+
+      mount(queryClient)
+
+      expect(invalidateSpy).not.toHaveBeenCalledWith({ queryKey: ['user', 'whoami'] })
+    })
+  })
+
   describe('review events', () => {
     const reviewMsg = (messageType: ReviewEventMessage['messageType']): ReviewEventMessage => ({
       messageType,
diff --git a/src/lib/apiError.test.ts b/src/lib/apiError.test.ts
index 2e8899fe7..f26a4862c 100644
--- a/src/lib/apiError.test.ts
+++ b/src/lib/apiError.test.ts
@@ -1,7 +1,7 @@
 import type { NormalizedOptions } from 'ky'
 import { HTTPError } from 'ky'
 import { describe, expect, it } from 'vitest'
-import { getApiErrorMessage, getLockConflict } from './apiError.ts'
+import { getApiErrorMessage, getLockConflict, getLockConflictInfo } from './apiError.ts'
 
 const makeHttpError = (body: unknown, status = 400) => {
   const response = new Response(JSON.stringify(body), { status })
@@ -93,3 +93,19 @@ describe('getLockConflict', () => {
     await expect(getLockConflict(error)).resolves.toBeUndefined()
   })
 })
+
+describe('getLockConflictInfo', () => {
+  it('includes the message field when it is a string', async () => {
+    const error = makeHttpError({ lockedTaskId: 7, message: 'already locked elsewhere' }, 409)
+    await expect(getLockConflictInfo(error)).resolves.toEqual(
+      expect.objectContaining({ lockedTaskId: 7, message: 'already locked elsewhere' })
+    )
+  })
+
+  it('omits the message field when it is not a string', async () => {
+    const error = makeHttpError({ lockedTaskId: 7, message: 123 }, 409)
+    await expect(getLockConflictInfo(error)).resolves.toEqual(
+      expect.objectContaining({ lockedTaskId: 7, message: undefined })
+    )
+  })
+})

From ca82fcf1818b2a94f433c3e847950bb07ec3f28b Mon Sep 17 00:00:00 2001
From: Collin Beczak <ctbeczak08@gmail.com>
Date: Thu, 6 Aug 2026 08:48:52 -0500
Subject: [PATCH 5/6] Extract task navigation into useNavigateToTask and
 simplify TaskContext lock-clearing

Dedupe the repeated navigate({ to: '/tasks/$taskId', ... claimTask: true }) call across
task-start/skip/nearby/random navigation and the lock-conflict dialog into a single
useNavigateToTask hook. Also collapse the three near-identical inline lock-clearing
callbacks in TaskContext into one clearLockState helper.
---
 src/api/task/single.ts                        |  6 ++
 .../ChallengePanel/ChallengeFooter.tsx        |  7 +-
 .../Pages/TaskEditPage/TaskActionModal.tsx    | 12 ++--
 .../TaskActions/NavigationActions.tsx         |  6 +-
 .../TaskEditPage/TaskActions/SkipButton.tsx   |  7 +-
 .../TaskActions/StartMappingActions.tsx       |  4 +-
 .../contexts/LockConflictDialog.tsx           |  6 +-
 .../TaskEditPage/contexts/TaskContext.tsx     | 70 ++++++++++++++-----
 .../TaskInfoPanel/TaskInfoDrawer.tsx          |  7 +-
 src/hooks/useNavigateToTask.ts                | 21 ++++++
 src/routes/_app/tasks/[$taskId]/index.tsx     |  1 +
 11 files changed, 104 insertions(+), 43 deletions(-)
 create mode 100644 src/hooks/useNavigateToTask.ts

diff --git a/src/api/task/single.ts b/src/api/task/single.ts
index 6de01727b..f642dccd6 100644
--- a/src/api/task/single.ts
+++ b/src/api/task/single.ts
@@ -70,6 +70,12 @@ export const taskSingle = {
     })
   },
 
+  useRefreshLock: () =>
+    useMutation({
+      mutationFn: (taskId: number) =>
+        apiRequest.get(`api/v2/task/${taskId}/refreshLock`).json<TaskStartResponse>(),
+    }),
+
   useUnlockTask: () => {
     const queryClient = useQueryClient()
     return useMutation({
diff --git a/src/components/Pages/BrowsedChallengePage/ChallengePanel/ChallengeFooter.tsx b/src/components/Pages/BrowsedChallengePage/ChallengePanel/ChallengeFooter.tsx
index b6405ee28..2a4dfe3d1 100644
--- a/src/components/Pages/BrowsedChallengePage/ChallengePanel/ChallengeFooter.tsx
+++ b/src/components/Pages/BrowsedChallengePage/ChallengePanel/ChallengeFooter.tsx
@@ -1,5 +1,4 @@
 import { useQueryClient } from '@tanstack/react-query'
-import { useNavigate } from '@tanstack/react-router'
 import { Flag, Map as MapIcon, Play } from 'lucide-react'
 import { useState } from 'react'
 import { toast } from 'sonner'
@@ -7,6 +6,7 @@ import { api } from '@/api'
 import { useBrowsedChallengeContext } from '@/components/Pages/BrowsedChallengePage/contexts/BrowsedChallengeContext'
 import { ChallengePausedNotice } from '@/components/shared/ChallengePausedNotice'
 import { Button } from '@/components/ui/Button'
+import { useNavigateToTask } from '@/hooks/useNavigateToTask'
 import { useIntl } from '@/i18n'
 import { logger } from '@/lib/logger'
 import { useMapToggle } from '../MapToggleContext'
@@ -14,7 +14,7 @@ import { ChallengeProgress } from './ChallengeProgress'
 
 export const ChallengeFooter = () => {
   const queryClient = useQueryClient()
-  const navigate = useNavigate()
+  const navigateToTask = useNavigateToTask()
   const { challenge, existingIssue } = useBrowsedChallengeContext()
   const { showMap, setShowMap } = useMapToggle()
   const { t } = useIntl()
@@ -29,8 +29,7 @@ export const ChallengeFooter = () => {
       const task = await api.challenge.getRandomTask(challenge.id, queryClient)
 
       if (task && task.length > 0) {
-        const taskId = task[0].id
-        await navigate({ to: '/tasks/$taskId', params: { taskId: String(taskId) } })
+        await navigateToTask(task[0].id)
       } else {
         toast.error(
           t(
diff --git a/src/components/Pages/TaskEditPage/TaskActionModal.tsx b/src/components/Pages/TaskEditPage/TaskActionModal.tsx
index 35bf03cd6..483748e64 100644
--- a/src/components/Pages/TaskEditPage/TaskActionModal.tsx
+++ b/src/components/Pages/TaskEditPage/TaskActionModal.tsx
@@ -25,6 +25,7 @@ import {
 } from '@/components/ui/Select'
 import { Textarea } from '@/components/ui/Textarea'
 import { useLockConflict } from '@/hooks/useLockConflict'
+import { useNavigateToTask } from '@/hooks/useNavigateToTask'
 import { useIntl } from '@/i18n'
 import { getApiErrorMessage } from '@/lib/apiError'
 import { logger } from '@/lib/logger'
@@ -50,6 +51,7 @@ export const TaskActionModal = ({
   const { t } = useIntl()
   const queryClient = useQueryClient()
   const navigate = useNavigate()
+  const navigateToTask = useNavigateToTask()
   const commentId = useId()
   const tagsId = useId()
   const randomId = useId()
@@ -161,10 +163,7 @@ export const TaskActionModal = ({
       )
 
       if (nextTaskType === 'nearby' && selectedNearbyTaskId) {
-        await navigate({
-          to: '/tasks/$taskId',
-          params: { taskId: String(selectedNearbyTaskId) },
-        })
+        await navigateToTask(selectedNearbyTaskId)
       } else {
         toast.info(
           t('taskEditPage.taskActionModal.toast.loadingNext', undefined, 'Loading next task...')
@@ -172,10 +171,7 @@ export const TaskActionModal = ({
         try {
           const randomTasks = await api.challenge.getRandomTask(task.parent, queryClient)
           if (randomTasks && randomTasks.length > 0) {
-            await navigate({
-              to: '/tasks/$taskId',
-              params: { taskId: String(randomTasks[0].id) },
-            })
+            await navigateToTask(randomTasks[0].id)
           } else {
             toast.info(
               t(
diff --git a/src/components/Pages/TaskEditPage/TaskActions/NavigationActions.tsx b/src/components/Pages/TaskEditPage/TaskActions/NavigationActions.tsx
index b4a6c506e..a8255bc83 100644
--- a/src/components/Pages/TaskEditPage/TaskActions/NavigationActions.tsx
+++ b/src/components/Pages/TaskEditPage/TaskActions/NavigationActions.tsx
@@ -5,6 +5,7 @@ import { useState } from 'react'
 import { toast } from 'sonner'
 import { api } from '@/api'
 import { Button } from '@/components/ui/Button'
+import { useNavigateToTask } from '@/hooks/useNavigateToTask'
 import { useIntl } from '@/i18n'
 
 export const NavigationActions = ({
@@ -16,6 +17,7 @@ export const NavigationActions = ({
 }) => {
   const { t } = useIntl()
   const navigate = useNavigate()
+  const navigateToTask = useNavigateToTask()
   const queryClient = useQueryClient()
   const [isLoadingNearby, setIsLoadingNearby] = useState(false)
   const [isLoadingRandom, setIsLoadingRandom] = useState(false)
@@ -28,7 +30,7 @@ export const NavigationActions = ({
         queryFn: () => api.challenge.fetchTasksNearby(challengeId, taskId, 1),
       })
       if (nearbyTasks && nearbyTasks.length > 0) {
-        await navigate({ to: '/tasks/$taskId', params: { taskId: String(nearbyTasks[0].id) } })
+        await navigateToTask(nearbyTasks[0].id)
       } else {
         toast.info(
           t(
@@ -56,7 +58,7 @@ export const NavigationActions = ({
     try {
       const randomTasks = await api.challenge.getRandomTask(challengeId, queryClient)
       if (randomTasks && randomTasks.length > 0) {
-        await navigate({ to: '/tasks/$taskId', params: { taskId: String(randomTasks[0].id) } })
+        await navigateToTask(randomTasks[0].id)
       } else {
         toast.info(
           t('common.noMoreTasksInChallenge', undefined, 'No more tasks available in this challenge')
diff --git a/src/components/Pages/TaskEditPage/TaskActions/SkipButton.tsx b/src/components/Pages/TaskEditPage/TaskActions/SkipButton.tsx
index 48845fa37..319fafb74 100644
--- a/src/components/Pages/TaskEditPage/TaskActions/SkipButton.tsx
+++ b/src/components/Pages/TaskEditPage/TaskActions/SkipButton.tsx
@@ -5,6 +5,7 @@ import { useState } from 'react'
 import { toast } from 'sonner'
 import { api } from '@/api'
 import { Button } from '@/components/ui/Button'
+import { useNavigateToTask } from '@/hooks/useNavigateToTask'
 import { useIntl } from '@/i18n'
 import { logger } from '@/lib/logger'
 import type { Task } from '@/types/Task'
@@ -12,6 +13,7 @@ import type { Task } from '@/types/Task'
 export const SkipButton = ({ task }: { task: Task }) => {
   const { t } = useIntl()
   const navigate = useNavigate()
+  const navigateToTask = useNavigateToTask()
   const queryClient = useQueryClient()
   const skip = api.task.useSkipTask()
   const [busy, setBusy] = useState(false)
@@ -26,10 +28,7 @@ export const SkipButton = ({ task }: { task: Task }) => {
 
       const randomTasks = await api.challenge.getRandomTask(task.parent, queryClient)
       if (randomTasks && randomTasks.length > 0) {
-        await navigate({
-          to: '/tasks/$taskId',
-          params: { taskId: String(randomTasks[0].id) },
-        })
+        await navigateToTask(randomTasks[0].id)
       } else {
         toast.info(
           t('common.noMoreTasksInChallenge', undefined, 'No more tasks available in this challenge')
diff --git a/src/components/Pages/TaskEditPage/TaskActions/StartMappingActions.tsx b/src/components/Pages/TaskEditPage/TaskActions/StartMappingActions.tsx
index 591400226..b99909f12 100644
--- a/src/components/Pages/TaskEditPage/TaskActions/StartMappingActions.tsx
+++ b/src/components/Pages/TaskEditPage/TaskActions/StartMappingActions.tsx
@@ -6,12 +6,14 @@ import { toast } from 'sonner'
 import { api } from '@/api'
 import { useTaskContext } from '@/components/Pages/TaskEditPage/contexts/TaskContext'
 import { Button } from '@/components/ui/Button'
+import { useNavigateToTask } from '@/hooks/useNavigateToTask'
 import { useIntl } from '@/i18n'
 
 export const StartMappingActions = ({ challengeId }: { challengeId: number }) => {
   const { t } = useIntl()
   const { isLocking, lockTask } = useTaskContext()
   const navigate = useNavigate()
+  const navigateToTask = useNavigateToTask()
   const queryClient = useQueryClient()
   const [isLoadingNext, setIsLoadingNext] = useState(false)
 
@@ -20,7 +22,7 @@ export const StartMappingActions = ({ challengeId }: { challengeId: number }) =>
     try {
       const randomTasks = await api.challenge.getRandomTask(challengeId, queryClient)
       if (randomTasks && randomTasks.length > 0) {
-        await navigate({ to: '/tasks/$taskId', params: { taskId: String(randomTasks[0].id) } })
+        await navigateToTask(randomTasks[0].id)
       } else {
         toast.info(
           t('common.noMoreTasksInChallenge', undefined, 'No more tasks available in this challenge')
diff --git a/src/components/Pages/TaskEditPage/contexts/LockConflictDialog.tsx b/src/components/Pages/TaskEditPage/contexts/LockConflictDialog.tsx
index b650ed338..f0ba0b106 100644
--- a/src/components/Pages/TaskEditPage/contexts/LockConflictDialog.tsx
+++ b/src/components/Pages/TaskEditPage/contexts/LockConflictDialog.tsx
@@ -1,4 +1,3 @@
-import { useNavigate } from '@tanstack/react-router'
 import { LockOpen } from 'lucide-react'
 import { Button } from '@/components/ui/Button'
 import {
@@ -9,6 +8,7 @@ import {
   DialogHeader,
   DialogTitle,
 } from '@/components/ui/Dialog'
+import { useNavigateToTask } from '@/hooks/useNavigateToTask'
 import { useIntl } from '@/i18n'
 import type { LockConflictInfo } from '@/lib/apiError'
 import { formatTimeAgo } from '@/lib/date'
@@ -22,12 +22,12 @@ interface Props {
 
 export const LockConflictDialog = ({ conflict, onOpenChange, onConfirm, busy }: Props) => {
   const { t, locale } = useIntl()
-  const navigate = useNavigate()
+  const navigateToTask = useNavigateToTask()
 
   const handleGoBack = () => {
     if (!conflict) return
     onOpenChange(false)
-    navigate({ to: '/tasks/$taskId', params: { taskId: String(conflict.lockedTaskId) } })
+    navigateToTask(conflict.lockedTaskId)
   }
 
   return (
diff --git a/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx b/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
index 4fc8fa3b0..a6cee149f 100644
--- a/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
+++ b/src/components/Pages/TaskEditPage/contexts/TaskContext.tsx
@@ -1,4 +1,4 @@
-import { useLoaderData } from '@tanstack/react-router'
+import { useLoaderData, useNavigate, useSearch } from '@tanstack/react-router'
 import type { ReactNode } from 'react'
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react'
 import { toast } from 'sonner'
@@ -15,6 +15,10 @@ import { LockConflictDialog } from './LockConflictDialog'
 // Statuses that allow editing: Created (0), Skipped (3), Too Hard/Can't Complete (6)
 export const EDITABLE_STATUSES = [0, 3, 6]
 
+// Well under the backend's 1-hour lock expiry (see Config.DEFAULT_TASK_LOCK_EXPIRY),
+// so an actively-open task never gets silently expired out from under the user.
+const LOCK_REFRESH_INTERVAL_MS = 15 * 60 * 1000
+
 export interface TaskContextType {
   task: Task
   isLocked: boolean
@@ -28,6 +32,8 @@ export const TaskContext = createContext<TaskContextType | undefined>(undefined)
 
 export const TaskProvider = ({ children }: { children: ReactNode }) => {
   const { task: loaderTask, challenge } = useLoaderData({ from: '/_app/tasks/$taskId/' })
+  const { claimTask: shouldClaimTask } = useSearch({ from: '/_app/tasks/$taskId/' })
+  const navigate = useNavigate()
   const { data: liveTask } = api.task.getTask(loaderTask.id)
   const task = liveTask ?? loaderTask
   const { user, isAuthenticated } = useAuthContext()
@@ -35,6 +41,7 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
   const { t } = useIntl()
   const lockTaskMutation = api.task.useLockTask()
   const unlockTaskMutation = api.task.useUnlockTask()
+  const refreshLockMutation = api.task.useRefreshLock()
   const hasAttemptedLock = useRef(false)
   const [isLocked, setIsLocked] = useState(false)
   const [lockedTasks, setLockedTasks] = useState<number[]>([])
@@ -42,6 +49,17 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
 
   const lockedTaskIdRef = useRef<number | null>(null)
 
+  // Clears local lock state after `id`'s lock is confirmed gone (release, expiry, or a
+  // conflicting claim elsewhere) - only nulls the ref if it still points at that same task,
+  // since a newer lock may have already superseded it.
+  const clearLockState = useCallback((id: number) => {
+    setIsLocked(false)
+    setLockedTasks([])
+    if (lockedTaskIdRef.current === id) {
+      lockedTaskIdRef.current = null
+    }
+  }, [])
+
   const attemptLock = useCallback(
     (taskId: number) => {
       lockTaskMutation.mutate(taskId, {
@@ -49,6 +67,12 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
           setIsLocked(true)
           lockedTaskIdRef.current = taskId
           setLockedTasks(data.lockBundledTasks.filter((id) => id !== taskId))
+          navigate({
+            to: '/tasks/$taskId',
+            params: { taskId: String(taskId) },
+            search: (prev) => ({ ...prev, claimTask: undefined }),
+            replace: true,
+          })
         },
         onError: async (error) => {
           setIsLocked(false)
@@ -68,7 +92,7 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
         },
       })
     },
-    [lockTaskMutation, t]
+    [lockTaskMutation, navigate, t]
   )
 
   useEffect(() => {
@@ -79,13 +103,13 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
   }, [task?.id])
 
   useEffect(() => {
-    if (!task || !isAuthenticated || hasAttemptedLock.current) return
+    if (!shouldClaimTask || !task || !isAuthenticated || hasAttemptedLock.current) return
     if (!EDITABLE_STATUSES.includes(task.status ?? 0)) return
     if (challenge?.paused) return
 
     hasAttemptedLock.current = true
     attemptLock(task.id)
-  }, [task, isAuthenticated, challenge?.paused, attemptLock])
+  }, [shouldClaimTask, task, isAuthenticated, challenge?.paused, attemptLock])
 
   useEffect(() => {
     return () => {
@@ -95,7 +119,27 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
         lockedTaskIdRef.current = null
       }
     }
-  }, [unlockTaskMutation.mutate])
+  }, [task?.id, unlockTaskMutation.mutate])
+
+  useEffect(() => {
+    if (!isLocked) return
+
+    // Silent keep-alive only - just extends locked_time so an actively-open
+    // task doesn't hit the backend's 1-hour lock expiry. Any actual conflict
+    // (another tab now holds a different task under this account) surfaces
+    // through the normal claim-a-different-task flow (attemptLock above),
+    // not from this background timer.
+    const interval = setInterval(() => {
+      const id = lockedTaskIdRef.current
+      if (id != null) {
+        refreshLockMutation.mutate(id, {
+          onError: () => clearLockState(id),
+        })
+      }
+    }, LOCK_REFRESH_INTERVAL_MS)
+
+    return () => clearInterval(interval)
+  }, [isLocked, refreshLockMutation.mutate, clearLockState])
 
   useEffect(() => {
     if (!task || !lastMessage || typeof lastMessage !== 'object') return
@@ -104,9 +148,7 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
     if (message.data?.task?.id !== task.id) return
 
     if (message.messageType === 'task-released') {
-      setIsLocked(false)
-      setLockedTasks([])
-      lockedTaskIdRef.current = null
+      clearLockState(task.id)
       return
     }
 
@@ -115,7 +157,7 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
     if (!claimedByMe) {
       lockedTaskIdRef.current = null
     }
-  }, [lastMessage, task, user?.id])
+  }, [lastMessage, task, user?.id, clearLockState])
 
   useEffect(() => {
     if (!task || !lastMessage || typeof lastMessage !== 'object') return
@@ -149,15 +191,9 @@ export const TaskProvider = ({ children }: { children: ReactNode }) => {
   const unlockTask = useCallback(() => {
     if (!task) return
     unlockTaskMutation.mutate(task.id, {
-      onSuccess: () => {
-        setIsLocked(false)
-        setLockedTasks([])
-        if (lockedTaskIdRef.current === task.id) {
-          lockedTaskIdRef.current = null
-        }
-      },
+      onSuccess: () => clearLockState(task.id),
     })
-  }, [task, unlockTaskMutation])
+  }, [task, unlockTaskMutation, clearLockState])
 
   const handleConfirmSwitchLock = useCallback(() => {
     if (!task || !lockConflict) return
diff --git a/src/components/TaskInfoPanel/TaskInfoDrawer.tsx b/src/components/TaskInfoPanel/TaskInfoDrawer.tsx
index c800702ec..794d117be 100644
--- a/src/components/TaskInfoPanel/TaskInfoDrawer.tsx
+++ b/src/components/TaskInfoPanel/TaskInfoDrawer.tsx
@@ -15,6 +15,7 @@ import { Button } from '@/components/ui/Button'
 import { Drawer } from '@/components/ui/Drawer'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/Popover'
 import { useDrawerTransition } from '@/hooks/useDrawerTransition'
+import { useNavigateToTask } from '@/hooks/useNavigateToTask'
 import { useIntl } from '@/i18n'
 import { getStatusLabel, STATUS_COLORS } from '@/lib/taskConstants'
 import { cn } from '@/lib/utils'
@@ -32,6 +33,7 @@ interface TaskInfoDrawerProps {
 export const TaskInfoDrawer = ({ selectedTask, onClose, mapRef }: TaskInfoDrawerProps) => {
   const { t } = useIntl()
   const navigate = useNavigate()
+  const navigateToTask = useNavigateToTask()
 
   const { data: fullTask } = api.task.getTask(selectedTask?.id ?? 0)
   const task = fullTask as Task | undefined
@@ -47,10 +49,7 @@ export const TaskInfoDrawer = ({ selectedTask, onClose, mapRef }: TaskInfoDrawer
 
   const handleStartTask = () => {
     if (task) {
-      navigate({
-        to: '/tasks/$taskId',
-        params: { taskId: task.id.toString() },
-      })
+      navigateToTask(task.id)
     }
   }
 
diff --git a/src/hooks/useNavigateToTask.ts b/src/hooks/useNavigateToTask.ts
new file mode 100644
index 000000000..3e602d863
--- /dev/null
+++ b/src/hooks/useNavigateToTask.ts
@@ -0,0 +1,21 @@
+import { useNavigate } from '@tanstack/react-router'
+
+/**
+ * Navigates to a task's edit page, claiming it by default (setting `claimTask=true` so
+ * TaskContext's auto-lock effect attempts to lock it) - this is what every "start"-style
+ * action (Start Task, Start Challenge, Complete & Continue, Skip, nearby/random task nav,
+ * lock-conflict "go back") wants. Pass `claim: false` for a rare read-only navigation that
+ * should just view the task without attempting a lock.
+ */
+export const useNavigateToTask = () => {
+  const navigate = useNavigate()
+
+  return (taskId: number | string, opts: { claim?: boolean } = {}) => {
+    const { claim = true } = opts
+    return navigate({
+      to: '/tasks/$taskId',
+      params: { taskId: String(taskId) },
+      search: claim ? { claimTask: true } : undefined,
+    })
+  }
+}
diff --git a/src/routes/_app/tasks/[$taskId]/index.tsx b/src/routes/_app/tasks/[$taskId]/index.tsx
index d53a267f1..4cb47750b 100644
--- a/src/routes/_app/tasks/[$taskId]/index.tsx
+++ b/src/routes/_app/tasks/[$taskId]/index.tsx
@@ -7,6 +7,7 @@ import { logger } from '@/lib/logger'
 
 const taskSearchSchema = z.object({
   tab: z.enum(['task', 'properties', 'comments', 'osm']).optional(),
+  claimTask: z.coerce.boolean().optional(),
 })
 
 export const Route = createFileRoute('/_app/tasks/$taskId/')({

From fdcc731d0e4e3acc3a8cf894e357a244122cc80b Mon Sep 17 00:00:00 2001
From: Collin Beczak <ctbeczak08@gmail.com>
Date: Thu, 6 Aug 2026 11:34:47 -0500
Subject: [PATCH 6/6] fix end to end tests

---
 docker-compose.test.yaml  | 7 ++++++-
 e2e/task-bundling.spec.ts | 5 +++++
 e2e/task-workflow.spec.ts | 6 ++++--
 3 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/docker-compose.test.yaml b/docker-compose.test.yaml
index 00d5739e7..0df431f4d 100644
--- a/docker-compose.test.yaml
+++ b/docker-compose.test.yaml
@@ -26,7 +26,12 @@ services:
       retries: 30
 
   backend:
-    image: ghcr.io/maproulette/maproulette-backend:4.9.0
+    # Pinned to `main` rather than a version tag: the dashboard team-list name
+    # display (teams.spec.ts) depends on the `teamName` field added to the
+    # memberships API in backend commit 8b445ce0 (2026-08-05), which hasn't
+    # made it into a versioned release yet (latest is 4.9.5, from 2026-07-16).
+    # Switch back to a version tag once one is cut past that commit.
+    image: ghcr.io/maproulette/maproulette-backend:main
     platform: linux/amd64 # TODO: remove once the image above supports multi-arch
     init: true
     depends_on:
diff --git a/e2e/task-bundling.spec.ts b/e2e/task-bundling.spec.ts
index 683f92c94..7d3ac48c9 100644
--- a/e2e/task-bundling.spec.ts
+++ b/e2e/task-bundling.spec.ts
@@ -10,6 +10,11 @@ test('a user can lasso-bundle a second task and clear the bundle', async ({
   await page.goto(`/tasks/${task.id}`)
 
   await expect(page.getByText(`Task #${task.id}`).first()).toBeVisible({ timeout: 15_000 })
+
+  // Opening a task URL directly no longer auto-claims it (only in-app
+  // navigation with claimTask=true does); clicking "Map this task" locks it,
+  // at which point the completion action buttons replace that prompt.
+  await page.getByRole('button', { name: 'Map this task' }).click()
   await expect(page.getByRole('button', { name: 'Fixed', exact: true })).toBeVisible({
     timeout: 20_000,
   })
diff --git a/e2e/task-workflow.spec.ts b/e2e/task-workflow.spec.ts
index 2a92113d8..ddbf21b39 100644
--- a/e2e/task-workflow.spec.ts
+++ b/e2e/task-workflow.spec.ts
@@ -15,8 +15,10 @@ test('a user can open a task, view its details, and mark it as fixed', async ({
   await expect(page.getByText(`Task #${task.id}`).first()).toBeVisible({ timeout: 15_000 })
   await expect(page.getByText('Fix the identified issue.')).toBeVisible({ timeout: 15_000 })
 
-  // The task auto-locks for mapping shortly after the page loads, at which point
-  // the completion action buttons replace the "Map this task" prompt.
+  // Opening a task URL directly no longer auto-claims it (only in-app
+  // navigation with claimTask=true does); clicking "Map this task" locks it,
+  // at which point the completion action buttons replace that prompt.
+  await page.getByRole('button', { name: 'Map this task' }).click()
   const fixedButton = page.getByRole('button', { name: 'Fixed', exact: true })
   await expect(fixedButton).toBeVisible({ timeout: 20_000 })
   await fixedButton.click()