@tuturuuu/ui 0.7.0 → 0.8.0

package/src/components/ui/tu-do/boards/boardId/task-board-server-page.tsx

@@ -1,6 +1,17 @@
+import {
+  getWorkspaceTaskBoard,
+  InternalApiError,
+  withForwardedInternalApiAuth,
+} from '@tuturuuu/internal-api';
+import type {
+  Workspace,
+  WorkspaceProductTier,
+  WorkspaceTaskBoard,
+} from '@tuturuuu/types';
 import { BoardClient } from '@tuturuuu/ui/tu-do/shared/board-client';
 import { getCurrentUser } from '@tuturuuu/utils/user-helper';
 import { getWorkspace } from '@tuturuuu/utils/workspace-helper';
+import { headers } from 'next/headers';
 import { notFound, redirect } from 'next/navigation';
 import type { ReactNode } from 'react';
 
@@ -14,6 +25,43 @@ interface Props {
   idleBottomIsland?: ReactNode;
 }
 
+type AuthorizedWorkspace = Workspace & {
+  joined: boolean;
+  tier: WorkspaceProductTier | null;
+};
+
+function createBoardGuestWorkspace(wsId: string): AuthorizedWorkspace {
+  return {
+    id: wsId,
+    joined: false,
+    personal: false,
+    tier: null,
+  } as AuthorizedWorkspace;
+}
+
+async function getAuthorizedBoard(wsId: string, boardId: string) {
+  try {
+    const { board } = await getWorkspaceTaskBoard(
+      wsId,
+      boardId,
+      withForwardedInternalApiAuth(await headers())
+    );
+
+    return board as WorkspaceTaskBoard & {
+      access_type?: 'member' | 'guest';
+    };
+  } catch (error) {
+    if (
+      error instanceof InternalApiError &&
+      (error.status === 401 || error.status === 403 || error.status === 404)
+    ) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
 /**
  * Shared Task Board Server Page component.
  * Handles workspace resolution and authentication.
@@ -29,14 +77,20 @@ export default async function TaskBoardServerPage({
   const user = await getCurrentUser();
   if (!user) redirect('/login');
 
-  const workspace = await getWorkspace(id, { useAdmin: true });
+  const board = await getAuthorizedBoard(id, boardId);
+  if (!board?.id) notFound();
+
+  const isMemberBoardAccess = board.access_type === 'member';
+  const workspace = isMemberBoardAccess
+    ? await getWorkspace(id, { useAdmin: true })
+    : createBoardGuestWorkspace(board.ws_id);
   if (!workspace) notFound();
 
   return (
     <BoardClient
       boardId={boardId}
       workspace={workspace}
-      workspaceTier={(workspace as any)?.tier ?? null}
+      workspaceTier={workspace.tier ?? null}
       currentUserId={user.id}
       routePrefix={routePrefix}
       idleBottomIsland={idleBottomIsland}

package/src/components/ui/tu-do/boards/boardId/timeline/timeline-display.ts

@@ -14,6 +14,15 @@ export const HANDLE_WIDTH = 12;
 export const DRAG_ACTIVATION_PX = 6;
 export const COLLAPSED_UNSCHEDULED_PREVIEW_COUNT = 4;
 
+export function getTimelineDayGridBackground(dayWidth: number, opacity = 0.45) {
+  const safeDayWidth = Math.max(1, dayWidth);
+  const lineStart = Math.max(0, safeDayWidth - 1);
+
+  return {
+    backgroundImage: `repeating-linear-gradient(to right, transparent 0, transparent ${lineStart}px, hsl(var(--border) / ${opacity}) ${lineStart}px, hsl(var(--border) / ${opacity}) ${safeDayWidth}px)`,
+  };
+}
+
 export function getDensityConfig(density: Density) {
   switch (density) {
     case 'compact':

package/src/components/ui/tu-do/boards/boardId/timeline/timeline-grid.tsx

@@ -6,7 +6,10 @@ import { cn } from '@tuturuuu/utils/format';
 import dayjs from 'dayjs';
 import type { useTranslations } from 'next-intl';
 import type { PointerEvent as ReactPointerEvent } from 'react';
-import { getListStatusBadgeClasses } from './timeline-display';
+import {
+  getListStatusBadgeClasses,
+  getTimelineDayGridBackground,
+} from './timeline-display';
 import { TimelineTaskRow } from './timeline-task-row';
 import type {
   TimelineInteractionMode,
@@ -197,7 +200,6 @@ export function TimelineGrid({
                 groupId={group.id}
                 localTasks={localTasks}
                 dayWidth={dayWidth}
-                timelineWidth={timelineWidth}
                 groupHeaderHeight={groupHeaderHeight}
                 isMoveTargetGroup={isMoveTargetGroup}
                 isPreviewGroup={isPreviewGroup}
@@ -257,7 +259,6 @@ export function TimelineGrid({
                   groupId={group.id}
                   localTasks={localTasks}
                   dayWidth={dayWidth}
-                  timelineWidth={timelineWidth}
                   groupHeaderHeight={rowHeight}
                   isMoveTargetGroup={isMoveTargetGroup}
                   isPreviewGroup={isPreviewGroup}
@@ -281,7 +282,6 @@ function TimelineGroupDropTarget({
   groupId,
   localTasks,
   dayWidth,
-  timelineWidth,
   groupHeaderHeight,
   isMoveTargetGroup,
   isPreviewGroup,
@@ -295,7 +295,6 @@ function TimelineGroupDropTarget({
   groupId: string;
   localTasks: Task[];
   dayWidth: number;
-  timelineWidth: number;
   groupHeaderHeight: number;
   isMoveTargetGroup: boolean;
   isPreviewGroup: boolean;
@@ -364,17 +363,10 @@ function TimelineGroupDropTarget({
             </div>
           );
         })()}
-      <div className="pointer-events-none absolute inset-0 flex">
-        {Array.from({
-          length: Math.max(1, Math.ceil(timelineWidth / dayWidth)),
-        }).map((_, index) => (
-          <div
-            key={`${groupId}-drop-${index}`}
-            className="h-full border-border/35 border-r"
-            style={{ width: dayWidth }}
-          />
-        ))}
-      </div>
+      <div
+        className="pointer-events-none absolute inset-0"
+        style={getTimelineDayGridBackground(dayWidth, 0.35)}
+      />
     </div>
   );
 }

package/src/components/ui/tu-do/boards/boardId/timeline/timeline-task-row.tsx

@@ -18,7 +18,6 @@ import {
   DropdownMenuSubTrigger,
 } from '@tuturuuu/ui/dropdown-menu';
 import { cn } from '@tuturuuu/utils/format';
-import dayjs from 'dayjs';
 import type { useTranslations } from 'next-intl';
 import type { PointerEvent as ReactPointerEvent } from 'react';
 import { useState } from 'react';
@@ -26,6 +25,7 @@ import { TaskRowActionsMenu } from '../../../shared/task-row-actions-menu';
 import {
   getStatusToneClasses,
   getTaskEyebrow,
+  getTimelineDayGridBackground,
   HANDLE_WIDTH,
 } from './timeline-display';
 import type {
@@ -263,30 +263,10 @@ export function TimelineTaskRow({
           style={{ minHeight: rowHeight }}
           onDoubleClick={() => onOpenEditor(item.task)}
         >
-          <div className="pointer-events-none absolute inset-0 flex">
-            {Array.from({
-              length: Math.max(1, Math.ceil(timelineWidth / dayWidth)),
-            }).map((_, index) => {
-              const isToday = todayVisible && index === todayIndex;
-              const date = item.start
-                ? dayjs(item.start).add(index - item.offsetDays, 'day')
-                : null;
-              const isWeekend = date ? [0, 6].includes(date.day()) : false;
-
-              return (
-                <div
-                  key={`${item.task.id}-${index}`}
-                  className={cn(
-                    'h-full border-border/45 border-r',
-                    index === 0 && 'border-l border-l-border/50',
-                    isWeekend && 'bg-muted/[0.12]',
-                    isToday && 'bg-dynamic-blue/[0.035]'
-                  )}
-                  style={{ width: dayWidth }}
-                />
-              );
-            })}
-          </div>
+          <div
+            className="pointer-events-none absolute inset-0 border-border/50 border-l"
+            style={getTimelineDayGridBackground(dayWidth)}
+          />
 
           {todayVisible && (
             <div

package/src/components/ui/tu-do/boards/boardId/timeline/timeline-utils.test.ts

@@ -1,7 +1,11 @@
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { buildTimelineModel, computeTimelineSpans } from './timeline-utils';
+import {
+  buildTimelineModel,
+  computeTimelineSpans,
+  MAX_TIMELINE_DAYS,
+} from './timeline-utils';
 
 const lists: TaskList[] = [
   {
@@ -108,6 +112,37 @@ describe('timeline row model', () => {
     );
   });
 
+  it('caps the rendered day window for extreme scheduled task ranges', () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-05-07T12:00:00.000Z'));
+
+    const model = buildTimelineModel(
+      [
+        task({
+          id: 'old-task',
+          name: 'Very old task',
+          start_date: '2020-01-01T00:00:00.000Z',
+          end_date: '2020-01-02T23:59:59.999Z',
+        }),
+        task({
+          id: 'future-task',
+          name: 'Very future task',
+          start_date: '2035-01-01T00:00:00.000Z',
+          end_date: '2035-01-02T23:59:59.999Z',
+        }),
+      ],
+      lists
+    );
+
+    expect(model.days).toHaveLength(MAX_TIMELINE_DAYS);
+    expect(model.rangeStart.getTime()).toBeLessThanOrEqual(
+      new Date('2026-05-07T00:00:00.000Z').getTime()
+    );
+    expect(model.rangeEnd.getTime()).toBeGreaterThanOrEqual(
+      new Date('2026-05-07T00:00:00.000Z').getTime()
+    );
+  });
+
   it('keeps span computation stable for existing analytics exports', () => {
     vi.useFakeTimers();
     vi.setSystemTime(new Date('2026-05-07T12:00:00.000Z'));

package/src/components/ui/tu-do/boards/boardId/timeline/timeline-utils.ts

@@ -62,6 +62,7 @@ const DEFAULT_PAST_PADDING_DAYS = 3;
 const DEFAULT_FUTURE_PADDING_DAYS = 6;
 const EMPTY_PAST_PADDING_DAYS = 7;
 const EMPTY_FUTURE_PADDING_DAYS = 14;
+export const MAX_TIMELINE_DAYS = 180;
 const TIMELINE_LIST_STATUS_ORDER: Record<string, number> = {
   not_started: 0,
   active: 1,
@@ -126,6 +127,48 @@ export function buildMonthSegments(days: Date[]) {
   return segments;
 }
 
+function capTimelineRange(
+  rangeStart: Date,
+  rangeEnd: Date,
+  todayMid: dayjs.Dayjs
+) {
+  const start = dayjs(rangeStart).startOf('day');
+  const end = dayjs(rangeEnd).startOf('day');
+  const totalDays = end.diff(start, 'day') + 1;
+
+  if (totalDays <= MAX_TIMELINE_DAYS) {
+    return {
+      rangeStart: start.toDate(),
+      rangeEnd: end.toDate(),
+    };
+  }
+
+  const latestStart = end.subtract(MAX_TIMELINE_DAYS - 1, 'day');
+  let cappedStart = start;
+
+  if (
+    (todayMid.isAfter(start) || todayMid.isSame(start, 'day')) &&
+    (todayMid.isBefore(end) || todayMid.isSame(end, 'day'))
+  ) {
+    cappedStart = todayMid.subtract(Math.floor(MAX_TIMELINE_DAYS / 2), 'day');
+  } else if (todayMid.isAfter(end)) {
+    cappedStart = latestStart;
+  }
+
+  if (cappedStart.isBefore(start)) {
+    cappedStart = start;
+  }
+
+  if (cappedStart.isAfter(latestStart)) {
+    cappedStart = latestStart;
+  }
+
+  return {
+    rangeStart: cappedStart.toDate(),
+    rangeEnd: cappedStart.add(MAX_TIMELINE_DAYS - 1, 'day').toDate(),
+  };
+}
+
 function withTaskRows(
   items: Array<Omit<TimelineItem, 'offsetDays'>>,
   rangeStart: Date
@@ -280,7 +323,7 @@ export function buildTimelineModel(
     });
   }
 
-  const rangeStart = scheduled.length
+  const rawRangeStart = scheduled.length
     ? dayjs(
         scheduled.reduce(
           (min, item) => (item.start < min ? item.start : min),
@@ -292,7 +335,7 @@ export function buildTimelineModel(
         .toDate()
     : todayMid.subtract(EMPTY_PAST_PADDING_DAYS, 'day').toDate();
 
-  const rangeEnd = scheduled.length
+  const rawRangeEnd = scheduled.length
     ? dayjs(
         scheduled.reduce(
           (max, item) => (item.end > max ? item.end : max),
@@ -304,6 +347,12 @@ export function buildTimelineModel(
         .toDate()
     : todayMid.add(EMPTY_FUTURE_PADDING_DAYS, 'day').toDate();
 
+  const { rangeStart, rangeEnd } = capTimelineRange(
+    rawRangeStart,
+    rawRangeEnd,
+    todayMid
+  );
+
   const days = enumerateDays(rangeStart, rangeEnd);
   const monthSegments = buildMonthSegments(days);
   const todayIndex = Math.round(

package/src/components/ui/tu-do/boards/workspace-projects-client-page.tsx

@@ -72,6 +72,15 @@ export default function WorkspaceProjectsClientPage({
   const isPermissionLoading = permissionQuery.isLoading;
 
   const resolvedWsId = workspace?.id;
+  const workspaceAccess = workspace as
+    | { access_type?: string; guest_products?: string[] }
+    | null
+    | undefined;
+  const isWorkspaceGuestTasksAccess =
+    workspaceAccess?.access_type === 'guest' &&
+    workspaceAccess.guest_products?.includes('tasks');
+  const canReadBoards =
+    canManageProjects === true || isWorkspaceGuestTasksAccess;
 
   const {
     data: boardsPayload,
@@ -85,9 +94,10 @@ export default function WorkspaceProjectsClientPage({
         page: Number.parseInt(page, 10),
         pageSize: Number.parseInt(pageSize, 10),
       }),
-    enabled: Boolean(resolvedWsId),
+    enabled: Boolean(resolvedWsId && canReadBoards),
   });
-  const isGuestBoardAccess = boardsPayload?.access_type === 'guest';
+  const isGuestBoardAccess =
+    isWorkspaceGuestTasksAccess || boardsPayload?.access_type === 'guest';
 
   useEffect(() => {
     if (
@@ -112,7 +122,7 @@ export default function WorkspaceProjectsClientPage({
     isWorkspacePending ||
     isWorkspaceUserLoading ||
     (isPermissionLoading && !isGuestBoardAccess) ||
-    isBoardsPending
+    (canReadBoards && isBoardsPending)
   ) {
     return <BoardsListSkeleton />;
   }

package/src/components/ui/tu-do/shared/__tests__/board-views.test.tsx

@@ -167,6 +167,7 @@ const mockTasks: Task[] = [
 const mockWorkspaceLabels: WorkspaceLabel[] = [];
 
 function renderBoardViews(overrides?: {
+  board?: Record<string, unknown>;
   idleBottomIsland?: React.ReactNode;
   lists?: TaskList[];
   tasks?: Task[];
@@ -184,7 +185,7 @@ function renderBoardViews(overrides?: {
     <QueryClientProvider client={queryClient}>
       <HotkeysProvider>
         <BoardViews
-          board={mockBoard as any}
+          board={(overrides?.board ?? mockBoard) as any}
           currentUserId="user-1"
           lists={overrides?.lists ?? mockLists}
           tasks={overrides?.tasks ?? mockTasks}
@@ -323,6 +324,38 @@ describe('BoardViews', () => {
     );
   });
 
+  it('creates a task in the board default list when configured', () => {
+    renderBoardViews({
+      board: { ...mockBoard, default_list_id: 'list-2' },
+    });
+
+    fireEvent.keyDown(document, { key: 'c' });
+
+    expect(createTaskMock).toHaveBeenCalledTimes(1);
+    expect(createTaskMock).toHaveBeenCalledWith(
+      'board-1',
+      'list-2',
+      mockLists,
+      expect.objectContaining({ labels: [] })
+    );
+  });
+
+  it('falls back to the first list when the default list is unavailable', () => {
+    renderBoardViews({
+      board: { ...mockBoard, default_list_id: 'list-does-not-exist' },
+    });
+
+    fireEvent.keyDown(document, { key: 'c' });
+
+    expect(createTaskMock).toHaveBeenCalledTimes(1);
+    expect(createTaskMock).toHaveBeenCalledWith(
+      'board-1',
+      'list-1',
+      mockLists,
+      expect.objectContaining({ labels: [] })
+    );
+  });
+
   it('pins a collapsed virtual external task list on personal boards without assigned external tasks', () => {
     renderBoardViews({
       workspace: {

package/src/components/ui/tu-do/shared/board-header.tsx

@@ -104,6 +104,7 @@ interface Props {
   > & {
     ws_id?: WorkspaceTaskBoard['ws_id'] | null;
     icon?: WorkspaceTaskBoard['icon'];
+    default_list_id?: WorkspaceTaskBoard['default_list_id'] | null;
   };
   currentUserId?: string;
   currentView: ViewType;
@@ -158,6 +159,9 @@ export function BoardHeader({
   const [showArchiveDialog, setShowArchiveDialog] = useState(false);
   const [showUnarchiveDialog, setShowUnarchiveDialog] = useState(false);
   const [ticketPrefix, setTicketPrefix] = useState(board.ticket_prefix || '');
+  const [defaultListId, setDefaultListId] = useState<string | null>(
+    board.default_list_id ?? null
+  );
   const [localSearchQuery, setLocalSearchQuery] = useState(
     filters.searchQuery || ''
   );
@@ -247,6 +251,7 @@ export function BoardHeader({
 
       await updateWorkspaceTaskBoard(workspaceId, board.id, {
         ticket_prefix: nextTicketPrefix,
+        default_list_id: defaultListId,
       });
 
       syncBoardTicketPrefixCaches({
@@ -911,6 +916,7 @@ export function BoardHeader({
                 <DropdownMenuItem
                   onClick={() => {
                     setTicketPrefix(board.ticket_prefix || '');
+                    setDefaultListId(board.default_list_id ?? null);
                     setBoardSettingsOpen(true);
                     setBoardMenuOpen(false);
                   }}
@@ -1163,6 +1169,39 @@ export function BoardHeader({
                 {t('ws-task-boards.settings.ticket_prefix_description')}
               </p>
             </div>
+            <div className="grid gap-2">
+              <label htmlFor="defaultList" className="font-medium text-sm">
+                {t('ws-task-boards.settings.default_list')}
+              </label>
+              <Select
+                value={defaultListId ?? '__none__'}
+                onValueChange={(value) =>
+                  setDefaultListId(value === '__none__' ? null : value)
+                }
+              >
+                <SelectTrigger id="defaultList">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="__none__">
+                    {t('ws-task-boards.settings.default_list_none')}
+                  </SelectItem>
+                  {lists
+                    .filter(
+                      (list) => !list.deleted && !list.is_external_staging
+                    )
+                    .map((list) => (
+                      <SelectItem key={list.id} value={list.id}>
+                        {list.name ||
+                          t('ws-task-boards.settings.untitled_list')}
+                      </SelectItem>
+                    ))}
+                </SelectContent>
+              </Select>
+              <p className="text-muted-foreground text-xs">
+                {t('ws-task-boards.settings.default_list_description')}
+              </p>
+            </div>
           </div>
           <DialogFooter>
             <Button

package/src/components/ui/tu-do/shared/board-views.tsx

@@ -519,14 +519,16 @@ export function BoardViews({
   useHotkey(
     HOTKEY_CREATE_TASK,
     () => {
-      const firstList = filteredLists.find((list) => !list.is_external_staging);
-      if (!firstList) return;
-      createTask(
-        board.id,
-        firstList.id,
-        filteredLists.filter((list) => !list.is_external_staging),
-        filters
+      const selectableLists = filteredLists.filter(
+        (list) => !list.is_external_staging
       );
+      // Prefer the board's configured default list for new tasks, falling back
+      // to the first selectable list when unset or the list is unavailable.
+      const targetList =
+        selectableLists.find((list) => list.id === board.default_list_id) ??
+        selectableLists[0];
+      if (!targetList) return;
+      createTask(board.id, targetList.id, selectableLists, filters);
     },
     {
       enabled: filteredLists.some((list) => !list.is_external_staging),

package/src/components/ui/tu-do/shared/cursor-overlay-multi-wrapper.tsx

@@ -11,6 +11,14 @@ import type { ListStatusFilter } from './board-header';
 import CursorOverlay from './cursor-overlay';
 import type { BoardFiltersMetadata, TaskFilters } from './task-filter.types';
 
+type CursorScopeMetadata =
+  | { type: 'board'; boardId: string }
+  | { type: 'task-description'; taskId: string };
+
+type CursorOverlayMetadata = Partial<BoardFiltersMetadata> & {
+  cursorScope: CursorScopeMetadata;
+};
+
 /**
  * Efficiently compares two sorted arrays of primitive values
  */
@@ -26,10 +34,16 @@ function arraysEqual<T extends string | number>(arr1: T[], arr2: T[]): boolean {
  * Checks if two cursor metadata objects represent the same view configuration
  */
 function isMatchingFilters(
-  metadata1?: BoardFiltersMetadata,
-  metadata2?: BoardFiltersMetadata
+  metadata1?: CursorOverlayMetadata,
+  metadata2?: CursorOverlayMetadata
 ): boolean {
   if (!metadata1 || !metadata2) return true; // Show all cursors if no metadata
+  if (!isMatchingCursorScope(metadata1.cursorScope, metadata2.cursorScope)) {
+    return false;
+  }
+
+  if (!metadata1.filters || !metadata2.filters) return true;
+  if (!metadata1.listStatusFilter || !metadata2.listStatusFilter) return true;
 
   // Check list status filter
   if (metadata1.listStatusFilter !== metadata2.listStatusFilter) return false;
@@ -81,14 +95,33 @@ function isMatchingFilters(
   return true;
 }
 
+function isMatchingCursorScope(
+  scope1: CursorScopeMetadata,
+  scope2: CursorScopeMetadata
+) {
+  if (scope1.type !== scope2.type) return false;
+  if (scope1.type === 'board' && scope2.type === 'board') {
+    return scope1.boardId === scope2.boardId;
+  }
+  if (
+    scope1.type === 'task-description' &&
+    scope2.type === 'task-description'
+  ) {
+    return scope1.taskId === scope2.taskId;
+  }
+  return false;
+}
+
 export default function CursorOverlayMultiWrapper({
   channelName,
   containerRef,
+  cursorScope,
   listStatusFilter,
   filters,
 }: {
   channelName: string;
   containerRef: React.RefObject<HTMLDivElement | null>;
+  cursorScope: CursorScopeMetadata;
   listStatusFilter?: ListStatusFilter;
   filters?: TaskFilters;
 }) {
@@ -97,6 +130,9 @@ export default function CursorOverlayMultiWrapper({
     height: number;
   }>({ width: 0, height: 0 });
   const [currentUser, setCurrentUser] = useState<User | null>(null);
+  const cursorScopeType = cursorScope.type;
+  const cursorScopeId =
+    cursorScope.type === 'board' ? cursorScope.boardId : cursorScope.taskId;
 
   // Fetch current user
   useEffect(() => {
@@ -105,10 +141,9 @@ export default function CursorOverlayMultiWrapper({
         const userData = await getCurrentUserProfile();
         if (!userData?.id) return;
         setCurrentUser({
-          id: userData.id,
-          display_name: userData.display_name,
-          email: userData.email,
           avatar_url: userData.avatar_url,
+          display_name: userData.display_name,
+          id: userData.id,
         });
       } catch (err) {
         console.warn('Error fetching user:', err);
@@ -118,14 +153,22 @@ export default function CursorOverlayMultiWrapper({
     fetchUser();
   }, []);
 
-  // Create metadata object from view options (only if both are provided)
-  const metadata: BoardFiltersMetadata | undefined = useMemo(() => {
-    if (!listStatusFilter || !filters) return undefined;
+  const metadata: CursorOverlayMetadata = useMemo(() => {
+    const resolvedCursorScope =
+      cursorScopeType === 'board'
+        ? ({ boardId: cursorScopeId, type: 'board' } as const)
+        : ({ taskId: cursorScopeId, type: 'task-description' } as const);
+
+    if (!listStatusFilter || !filters) {
+      return { cursorScope: resolvedCursorScope };
+    }
+
     return {
+      cursorScope: resolvedCursorScope,
       listStatusFilter,
       filters,
     };
-  }, [listStatusFilter, filters]);
+  }, [cursorScopeId, cursorScopeType, listStatusFilter, filters]);
 
   const { cursors, error } = useCursorTracking(
     channelName,
@@ -139,15 +182,13 @@ export default function CursorOverlayMultiWrapper({
     const filtered = new Map<string, CursorPosition>();
 
     for (const [userId, cursor] of cursors.entries()) {
-      // Always show cursors without metadata (backward compatibility)
       if (!cursor.metadata) {
-        filtered.set(userId, cursor);
         continue;
       }
 
       // Filter based on view matching
       if (
-        isMatchingFilters(metadata, cursor.metadata as BoardFiltersMetadata)
+        isMatchingFilters(metadata, cursor.metadata as CursorOverlayMetadata)
       ) {
         filtered.set(userId, cursor);
       }