@tuturuuu/ui 0.8.0 → 0.9.0

package/src/components/ui/tu-do/boards/boardId/kanban/bulk/bulk-mutations-clear-delete.ts

@@ -4,6 +4,7 @@ import { type QueryClient, useMutation } from '@tanstack/react-query';
 import { bulkWorkspaceTasks } from '@tuturuuu/internal-api/tasks';
 import { toast } from '@tuturuuu/ui/sonner';
 import type { BoardBroadcastFn } from '../../../../shared/board-broadcast-context';
+import { invalidateKanbanDeadlineTasks } from '../data/kanban-deadline-query';
 import type { BulkOperationI18n } from './bulk-operation-i18n';
 import {
   type BulkTaskWorkspaceGroup,
@@ -390,6 +391,7 @@ export function useBulkDeleteTasks(
       for (const tid of succeededTaskIds) {
         broadcast?.('task:delete', { taskId: tid });
       }
+      void invalidateKanbanDeadlineTasks(queryClient, boardId);
 
       clearSelection();
       setBulkDeleteOpen(false);

package/src/components/ui/tu-do/boards/boardId/kanban/bulk/bulk-mutations-move.ts

@@ -6,6 +6,7 @@ import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
 import { toast } from '@tuturuuu/ui/sonner';
 import type { BoardBroadcastFn } from '../../../../shared/board-broadcast-context';
+import { invalidateKanbanDeadlineTasks } from '../data/kanban-deadline-query';
 import type { BulkOperationI18n } from './bulk-operation-i18n';
 import { getInternalApiOptions } from './bulk-operation-utils';
 import {
@@ -184,6 +185,8 @@ export function useBulkMoveToBoard(
       for (const tid of movedTaskIds) {
         broadcast?.('task:delete', { taskId: tid });
       }
+      void invalidateKanbanDeadlineTasks(queryClient, boardId);
+      void invalidateKanbanDeadlineTasks(queryClient, data.targetBoardId);
 
       if (data.failures.length > 0) {
         toast.warning(
@@ -428,6 +431,7 @@ export function useBulkMoveToList(
           },
         });
       }
+      void invalidateKanbanDeadlineTasks(queryClient, boardId);
 
       if (data.failures.length > 0) {
         toast.warning(
@@ -631,6 +635,7 @@ export function useBulkMoveToStatus(
           },
         });
       }
+      void invalidateKanbanDeadlineTasks(queryClient, boardId);
 
       if (data.failures.length > 0) {
         toast.warning(

package/src/components/ui/tu-do/boards/boardId/kanban/bulk/bulk-mutations-updates.ts

@@ -4,6 +4,7 @@ import { type QueryClient, useMutation } from '@tanstack/react-query';
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import { toast } from '@tuturuuu/ui/sonner';
 import type { BoardBroadcastFn } from '../../../../shared/board-broadcast-context';
+import { invalidateKanbanDeadlineTasks } from '../data/kanban-deadline-query';
 import type { BulkOperationI18n } from './bulk-operation-i18n';
 import {
   bulkWorkspaceTasksByEffectiveWorkspace,
@@ -322,6 +323,7 @@ export function useBulkUpdateDueDate(
           task: { id: tid, end_date: data.end_date },
         });
       }
+      void invalidateKanbanDeadlineTasks(queryClient, boardId);
 
       if (data.failures.length > 0) {
         toast.warning(
@@ -434,6 +436,7 @@ export function useBulkUpdateCustomDueDate(
           task: { id: tid, end_date: data.end_date },
         });
       }
+      void invalidateKanbanDeadlineTasks(queryClient, boardId);
 
       if (data.failures.length > 0) {
         toast.warning(

package/src/components/ui/tu-do/boards/boardId/kanban/data/kanban-deadline-query.ts

@@ -1,22 +1,70 @@
+import type { QueryClient } from '@tanstack/react-query';
 import { listWorkspaceTasks } from '@tuturuuu/internal-api';
+import type { ListWorkspaceTasksOptions } from '@tuturuuu/internal-api/tasks';
 import type { Task } from '@tuturuuu/types/primitives/Task';
 
 const KANBAN_DEADLINE_TASK_PAGE_SIZE = 200;
+export const KANBAN_DEADLINE_TASKS_QUERY_KEY = 'kanban-deadline-tasks';
+
+export function getKanbanDeadlineTasksQueryKey(
+  workspaceId: string,
+  boardId: string | null | undefined,
+  taskQueryOptions?: ListWorkspaceTasksOptions
+) {
+  return [
+    KANBAN_DEADLINE_TASKS_QUERY_KEY,
+    workspaceId,
+    boardId,
+    taskQueryOptions,
+  ] as const;
+}
+
+export function invalidateKanbanDeadlineTasks(
+  queryClient: QueryClient,
+  boardId?: string | null
+) {
+  return queryClient.invalidateQueries({
+    predicate: (query) => {
+      const queryKey = query.queryKey;
+      if (!Array.isArray(queryKey)) return false;
+      if (queryKey[0] !== KANBAN_DEADLINE_TASKS_QUERY_KEY) return false;
+      return !boardId || queryKey[2] === boardId;
+    },
+  });
+}
 
 interface ListKanbanDeadlineTasksOptions {
   boardId: string;
+  taskQueryOptions?: ListWorkspaceTasksOptions;
   workspaceId: string;
 }
 
 export async function listKanbanDeadlineTasks({
   boardId,
+  taskQueryOptions,
   workspaceId,
 }: ListKanbanDeadlineTasksOptions): Promise<Task[]> {
   const tasks: Task[] = [];
   let offset = 0;
+  const {
+    boardId: _boardId,
+    closed: _closed,
+    completed: _completed,
+    externalSortBy: _externalSortBy,
+    hasDueDate: _hasDueDate,
+    includeCount: _includeCount,
+    includeListCounts: _includeListCounts,
+    includeRelationshipSummary: _includeRelationshipSummary,
+    limit: _limit,
+    listId: _listId,
+    offset: _offset,
+    sortBy: _sortBy,
+    ...filterOptions
+  } = taskQueryOptions ?? {};
 
   while (true) {
     const response = await listWorkspaceTasks(workspaceId, {
+      ...filterOptions,
       boardId,
       closed: 'exclude',
       completed: 'exclude',
@@ -25,9 +73,9 @@ export async function listKanbanDeadlineTasks({
       includeCount: true,
       includeRelationshipSummary: false,
       limit: KANBAN_DEADLINE_TASK_PAGE_SIZE,
-      listStatuses: ['not_started', 'active'],
+      listStatuses: filterOptions.listStatuses ?? ['not_started', 'active'],
       offset,
-      sourceScope: 'all_visible',
+      sourceScope: filterOptions.sourceScope ?? 'all_visible',
     });
 
     tasks.push(...response.tasks);

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/__tests__/column-reorder.test.ts

@@ -43,6 +43,23 @@ describe('getColumnReorderUpdates', () => {
     expect(getColumnReorderUpdates(columns, 'todo', 'doing')).toBeNull();
   });
 
+  it('excludes synthetic external staging lanes from persisted position repairs', () => {
+    const externalLane = {
+      ...makeList('external', 'not_started', -1),
+      is_external_staging: true,
+    };
+    const columns = [
+      externalLane,
+      makeList('todo', 'not_started', 0),
+      makeList('backlog', 'not_started', 1),
+    ];
+
+    expect(getColumnReorderUpdates(columns, 'backlog', 'todo')).toEqual([
+      { listId: 'backlog', newPosition: 0 },
+      { listId: 'todo', newPosition: 1 },
+    ]);
+  });
+
   it('sorts columns in the same order they are rendered in Kanban', () => {
     const columns = [
       makeList('closed', 'closed', 0),

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/column-reorder.ts

@@ -39,7 +39,10 @@ export function getColumnReorderUpdates(
   }
 
   const statusColumns = [...columns]
-    .filter((column) => column.status === activeColumn.status)
+    .filter(
+      (column) =>
+        column.status === activeColumn.status && !column.is_external_staging
+    )
     .sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
 
   const activeIndex = statusColumns.findIndex(

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-drag-cache.ts

@@ -3,17 +3,27 @@ import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
 import { MAX_SAFE_INTEGER_SORT } from '../kanban-constants';
 import type { DragCacheSnapshot, TaskSortKeyRepair } from './task-drag-types';
+import { getEffectiveTaskSortKey } from './task-sort-key';
 
 const SORT_KEY_BASE_UNIT = 1_000_000;
 const SORT_KEY_DEFAULT = SORT_KEY_BASE_UNIT * 1000;
 const SORT_KEY_MIN_GAP = 1000;
 
+type SortKeyPlanTask = Pick<
+  Task,
+  | 'id'
+  | 'is_personal_external'
+  | 'is_personal_external_default'
+  | 'personal_sort_key'
+  | 'sort_key'
+>;
+
 function getTaskSortKeyInsertionContext({
   activeTaskId,
   orderedTasks,
 }: {
   activeTaskId: string;
-  orderedTasks: Pick<Task, 'id' | 'sort_key'>[];
+  orderedTasks: SortKeyPlanTask[];
 }) {
   const activeIndex = orderedTasks.findIndex(
     (task) => task.id === activeTaskId
@@ -26,10 +36,15 @@ function getTaskSortKeyInsertionContext({
     };
   }
 
+  const nextTask = orderedTasks[activeIndex + 1];
+  const previousTask = orderedTasks[activeIndex - 1];
+
   return {
     activeIndex,
-    nextSortKey: orderedTasks[activeIndex + 1]?.sort_key ?? null,
-    previousSortKey: orderedTasks[activeIndex - 1]?.sort_key ?? null,
+    nextSortKey: nextTask ? getEffectiveTaskSortKey(nextTask) : null,
+    previousSortKey: previousTask
+      ? getEffectiveTaskSortKey(previousTask)
+      : null,
   };
 }
 
@@ -94,7 +109,7 @@ function getPreviewSortKeyPlan({
   targetListId,
 }: {
   activeTaskId: string;
-  orderedTasks: Pick<Task, 'id' | 'sort_key'>[];
+  orderedTasks: SortKeyPlanTask[];
   targetListId: string;
 }): {
   previewSortKey: number;
@@ -119,10 +134,14 @@ function getPreviewSortKeyPlan({
   });
   const effectiveOrderedTasks = orderedTasks.map((task) => ({
     ...task,
-    sort_key: task.id === activeTaskId ? previewSortKey : task.sort_key,
+    effective_sort_key:
+      task.id === activeTaskId ? previewSortKey : getEffectiveTaskSortKey(task),
   }));
   const orderNeedsRepair = effectiveOrderedTasks.some((task, index) => {
-    if (typeof task.sort_key !== 'number' || !Number.isFinite(task.sort_key)) {
+    if (
+      typeof task.effective_sort_key !== 'number' ||
+      !Number.isFinite(task.effective_sort_key)
+    ) {
       return true;
     }
 
@@ -130,13 +149,16 @@ function getPreviewSortKeyPlan({
     if (!previousTask) return false;
 
     if (
-      typeof previousTask.sort_key !== 'number' ||
-      !Number.isFinite(previousTask.sort_key)
+      typeof previousTask.effective_sort_key !== 'number' ||
+      !Number.isFinite(previousTask.effective_sort_key)
     ) {
       return true;
     }
 
-    return task.sort_key - previousTask.sort_key < SORT_KEY_MIN_GAP;
+    return (
+      task.effective_sort_key - previousTask.effective_sort_key <
+      SORT_KEY_MIN_GAP
+    );
   });
 
   if (
@@ -197,6 +219,9 @@ export function getTaskDropPreviewCacheTasks({
             ...task,
             list_id: targetListId,
             sort_key: previewSortKey,
+            personal_sort_key: task.is_personal_external
+              ? previewSortKey
+              : task.personal_sort_key,
             completed: targetIsCompleted,
             completed_at: targetIsCompleted
               ? (task.completed_at ?? mutationTimestamp)
@@ -210,6 +235,10 @@ export function getTaskDropPreviewCacheTasks({
           ? ({
               ...task,
               sort_key: repairedSortKeysByTaskId.get(task.id) ?? task.sort_key,
+              personal_sort_key: task.is_personal_external
+                ? (repairedSortKeysByTaskId.get(task.id) ??
+                  task.personal_sort_key)
+                : task.personal_sort_key,
               _localMutationAt: localMutationAt,
             } as Task & { _localMutationAt: number })
           : task

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-drag-order.ts

@@ -1,7 +1,7 @@
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
-import { MAX_SAFE_INTEGER_SORT } from '../kanban-constants';
 import type { DragPreviewPosition, TaskDropPosition } from './task-drag-types';
+import { compareTasksByEffectiveSortKey } from './task-sort-key';
 
 export function getNeighborTaskIds(tasks: Task[], taskId: string) {
   const taskIndex = tasks.findIndex((task) => task.id === taskId);
@@ -142,13 +142,7 @@ export function sortTasksForList({
     }
 
     if (!disableSort) {
-      const sortA = a.sort_key ?? MAX_SAFE_INTEGER_SORT;
-      const sortB = b.sort_key ?? MAX_SAFE_INTEGER_SORT;
-      if (sortA !== sortB) return sortA - sortB;
-      if (!a.created_at || !b.created_at) return 0;
-      return (
-        new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
-      );
+      return compareTasksByEffectiveSortKey(a, b);
     }
 
     return 0;

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-sort-key.ts

@@ -0,0 +1,47 @@
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import { MAX_SAFE_INTEGER_SORT } from '../kanban-constants';
+
+type SortKeyTask = Pick<
+  Task,
+  | 'is_personal_external'
+  | 'is_personal_external_default'
+  | 'personal_sort_key'
+  | 'sort_key'
+>;
+
+type SortableTask = SortKeyTask & Pick<Task, 'created_at'>;
+
+export function getEffectiveTaskSortKey(task: SortKeyTask) {
+  if (typeof task.sort_key === 'number' && Number.isFinite(task.sort_key)) {
+    return task.sort_key;
+  }
+
+  if (
+    task.is_personal_external === true &&
+    task.is_personal_external_default !== true &&
+    typeof task.personal_sort_key === 'number' &&
+    Number.isFinite(task.personal_sort_key)
+  ) {
+    return task.personal_sort_key;
+  }
+
+  return null;
+}
+
+export function compareTasksByEffectiveSortKey(
+  left: SortableTask,
+  right: SortableTask
+) {
+  const leftSortKey = getEffectiveTaskSortKey(left) ?? MAX_SAFE_INTEGER_SORT;
+  const rightSortKey = getEffectiveTaskSortKey(right) ?? MAX_SAFE_INTEGER_SORT;
+
+  if (leftSortKey !== rightSortKey) {
+    return leftSortKey - rightSortKey;
+  }
+
+  if (!left.created_at || !right.created_at) return 0;
+
+  return (
+    new Date(left.created_at).getTime() - new Date(right.created_at).getTime()
+  );
+}

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/use-kanban-dnd.ts

@@ -22,6 +22,7 @@ import {
 import { hasDraggableData } from '@tuturuuu/utils/task-helpers';
 import { useCallback, useRef, useState } from 'react';
 import { useBoardBroadcast } from '../../../../shared/board-broadcast-context';
+import { invalidateKanbanDeadlineTasks } from '../data/kanban-deadline-query';
 import { MAX_SAFE_INTEGER_SORT } from '../kanban-constants';
 import { useAutoScroll } from './auto-scroll';
 import { getColumnReorderUpdates } from './column-reorder';
@@ -62,6 +63,10 @@ import type {
   TaskRect,
   VerticalRect,
 } from './task-drag-types';
+import {
+  compareTasksByEffectiveSortKey,
+  getEffectiveTaskSortKey,
+} from './task-sort-key';
 
 export {
   applyTaskDropPreviewToCache,
@@ -1162,14 +1167,14 @@ export function useKanbanDnd({
             const nextTask = projectedDropOrder[1];
             newSortKey = await calculateSortKeyWithRetry(
               null,
-              nextTask?.sort_key ?? null,
+              nextTask ? getEffectiveTaskSortKey(nextTask) : null,
               targetListId,
               projectedDropOrder
             );
           } else if (newIndex === projectedDropOrder.length - 1) {
             const prevTask = projectedDropOrder[projectedDropOrder.length - 2];
             newSortKey = await calculateSortKeyWithRetry(
-              prevTask?.sort_key ?? null,
+              prevTask ? getEffectiveTaskSortKey(prevTask) : null,
               null,
               targetListId,
               projectedDropOrder
@@ -1178,8 +1183,8 @@ export function useKanbanDnd({
             const prevTask = projectedDropOrder[newIndex - 1];
             const nextTask = projectedDropOrder[newIndex + 1];
             newSortKey = await calculateSortKeyWithRetry(
-              prevTask?.sort_key ?? null,
-              nextTask?.sort_key ?? null,
+              prevTask ? getEffectiveTaskSortKey(prevTask) : null,
+              nextTask ? getEffectiveTaskSortKey(nextTask) : null,
               targetListId,
               projectedDropOrder
             );
@@ -1195,7 +1200,8 @@ export function useKanbanDnd({
       const needsUpdate =
         dropChangesVisualOrder ||
         (newSortKey !== null &&
-          (activeTaskForDrop.sort_key ?? MAX_SAFE_INTEGER_SORT) !== newSortKey);
+          (getEffectiveTaskSortKey(activeTaskForDrop) ??
+            MAX_SAFE_INTEGER_SORT) !== newSortKey);
 
       let shouldPreservePendingAfterDragReset = false;
       const persistPersonalPlacementMove = (
@@ -1211,6 +1217,19 @@ export function useKanbanDnd({
         shouldPreservePendingAfterDragReset = true;
 
         void movePersonalPlacementTask(task, targetListId, sortKey, order)
+          .then((updatedTask) => {
+            broadcast?.('task:upsert', {
+              task: {
+                id: updatedTask.id,
+                list_id: updatedTask.list_id,
+                sort_key: updatedTask.sort_key,
+                personal_sort_key: updatedTask.personal_sort_key,
+                completed_at: updatedTask.completed_at,
+                closed_at: updatedTask.closed_at,
+              },
+            });
+            void invalidateKanbanDeadlineTasks(queryClient, boardId);
+          })
           .catch((error) => {
             console.error('Failed to update personal task placement:', error);
             rollbackOptimisticDropPreview();
@@ -1231,16 +1250,9 @@ export function useKanbanDnd({
             .map((taskId) => baseTasks.find((t) => t.id === taskId))
             .filter((t): t is Task => t !== undefined);
 
-          const sortedTasksToMove = selectedTaskObjects.sort((a, b) => {
-            const sortA = a.sort_key ?? MAX_SAFE_INTEGER_SORT;
-            const sortB = b.sort_key ?? MAX_SAFE_INTEGER_SORT;
-            if (sortA !== sortB) return sortA - sortB;
-            if (!a.created_at || !b.created_at) return 0;
-            return (
-              new Date(a.created_at).getTime() -
-              new Date(b.created_at).getTime()
-            );
-          });
+          const sortedTasksToMove = selectedTaskObjects.sort(
+            compareTasksByEffectiveSortKey
+          );
 
           if (
             targetIsExternalStaging &&
@@ -1306,7 +1318,7 @@ export function useKanbanDnd({
                 const nextTask = simulatedTargetList[1];
                 batchSortKey = await calculateSortKeyWithRetry(
                   null,
-                  nextTask?.sort_key ?? null,
+                  nextTask ? getEffectiveTaskSortKey(nextTask) : null,
                   targetListId,
                   targetListTasks
                 );
@@ -1316,7 +1328,7 @@ export function useKanbanDnd({
               ) {
                 const prevTask = simulatedTargetList[positionInSimulated - 1];
                 batchSortKey = await calculateSortKeyWithRetry(
-                  prevTask?.sort_key ?? null,
+                  prevTask ? getEffectiveTaskSortKey(prevTask) : null,
                   null,
                   targetListId,
                   targetListTasks
@@ -1334,8 +1346,8 @@ export function useKanbanDnd({
 
                 if (!prevIsMoving && !nextIsMoving) {
                   batchSortKey = await calculateSortKeyWithRetry(
-                    prevTask?.sort_key ?? null,
-                    nextTask?.sort_key ?? null,
+                    prevTask ? getEffectiveTaskSortKey(prevTask) : null,
+                    nextTask ? getEffectiveTaskSortKey(nextTask) : null,
                     targetListId,
                     targetListTasks
                   );
@@ -1349,8 +1361,10 @@ export function useKanbanDnd({
                     }
                   }
                   batchSortKey = await calculateSortKeyWithRetry(
-                    stationaryPrev?.sort_key ?? null,
-                    nextTask?.sort_key ?? null,
+                    stationaryPrev
+                      ? getEffectiveTaskSortKey(stationaryPrev)
+                      : null,
+                    nextTask ? getEffectiveTaskSortKey(nextTask) : null,
                     targetListId,
                     targetListTasks
                   );
@@ -1368,8 +1382,10 @@ export function useKanbanDnd({
                     }
                   }
                   batchSortKey = await calculateSortKeyWithRetry(
-                    prevTask?.sort_key ?? null,
-                    stationaryNext?.sort_key ?? null,
+                    prevTask ? getEffectiveTaskSortKey(prevTask) : null,
+                    stationaryNext
+                      ? getEffectiveTaskSortKey(stationaryNext)
+                      : null,
                     targetListId,
                     targetListTasks
                   );
@@ -1398,8 +1414,8 @@ export function useKanbanDnd({
                   }
 
                   batchSortKey = await calculateSortKeyWithRetry(
-                    boundaryPrev?.sort_key ?? null,
-                    boundaryNext?.sort_key ?? null,
+                    boundaryPrev ? getEffectiveTaskSortKey(boundaryPrev) : null,
+                    boundaryNext ? getEffectiveTaskSortKey(boundaryNext) : null,
                     targetListId,
                     targetListTasks
                   );
@@ -1430,6 +1446,7 @@ export function useKanbanDnd({
                           closed_at: updatedTask.closed_at,
                         },
                       });
+                      void invalidateKanbanDeadlineTasks(queryClient, boardId);
                     },
                     onSettled: () => {
                       clearPendingTaskIds(pendingTaskIds);
@@ -1475,14 +1492,45 @@ export function useKanbanDnd({
                   closed_at: updatedTask.closed_at,
                 },
               });
+              void invalidateKanbanDeadlineTasks(queryClient, boardId);
             };
 
             if (repairedTaskSortKeys.length > 0) {
               void (async () => {
                 try {
+                  const repairTaskById = new Map<string, Task>();
+                  for (const task of [
+                    ...baseTasks,
+                    ...(optimisticDropPreview?.previousTasks ?? []),
+                    ...(optimisticDropPreview?.previousFullTasks ?? []),
+                  ]) {
+                    repairTaskById.set(task.id, task);
+                  }
+
                   const results = await Promise.allSettled(
-                    repairedTaskSortKeys.map((repair) =>
-                      reorderTaskMutation.mutateAsync(
+                    repairedTaskSortKeys.map(async (repair) => {
+                      const repairTask = repairTaskById.get(repair.taskId);
+
+                      if (repairTask && usesPersonalPlacement(repairTask)) {
+                        const updatedTask = await movePersonalPlacementTask(
+                          repairTask,
+                          repair.listId,
+                          repair.sortKey
+                        );
+                        broadcast?.('task:upsert', {
+                          task: {
+                            id: updatedTask.id,
+                            list_id: updatedTask.list_id,
+                            sort_key: updatedTask.sort_key,
+                            personal_sort_key: updatedTask.personal_sort_key,
+                            completed_at: updatedTask.completed_at,
+                            closed_at: updatedTask.closed_at,
+                          },
+                        });
+                        return updatedTask;
+                      }
+
+                      return reorderTaskMutation.mutateAsync(
                         {
                           taskId: repair.taskId,
                           newListId: repair.listId,
@@ -1495,14 +1543,17 @@ export function useKanbanDnd({
                         {
                           onSuccess: handleReorderSuccess,
                         }
-                      )
-                    )
+                      );
+                    })
                   );
                   const failedResults = results.filter(
                     (result) => result.status === 'rejected'
                   );
 
-                  if (failedResults.length === 0) return;
+                  if (failedResults.length === 0) {
+                    void invalidateKanbanDeadlineTasks(queryClient, boardId);
+                    return;
+                  }
 
                   console.error(
                     'Failed to persist repaired task sort keys:',