@tuturuuu/ui 0.11.1 → 0.13.0

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

@@ -1,7 +1,23 @@
 import { QueryClient } from '@tanstack/react-query';
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('@tuturuuu/utils/task-helper', () => {
+  const prefix = 'personal-external-staging:';
+
+  return {
+    getPersonalExternalStagingBoardId: (listId: string | null) =>
+      listId?.startsWith(prefix) && listId.length > prefix.length
+        ? listId.slice(prefix.length)
+        : null,
+    getPersonalExternalStagingListId: (boardId: string) =>
+      `${prefix}${boardId}`,
+    isPersonalExternalStagingListId: (listId: string | null) =>
+      Boolean(listId?.startsWith(prefix) && listId.length > prefix.length),
+  };
+});
+
 import {
   applyTaskDropPreviewToCache,
   getProjectedTaskDropOrderFromPreview,
@@ -14,6 +30,7 @@ import {
   insertTaskAtDropPosition,
   mergePersonalPlacementMutationTask,
   mergeTaskIntoBoardTaskCache,
+  usesPersonalPlacement,
 } from './use-kanban-dnd';
 
 function createTask(overrides: Partial<Task> = {}): Task {
@@ -116,6 +133,51 @@ describe('mergePersonalPlacementMutationTask', () => {
   });
 });
 
+describe('usesPersonalPlacement', () => {
+  it('does not treat a personal-workspace task as external from personal_board_id alone', () => {
+    const personalTask = createTask({
+      is_personal_external: false,
+      personal_board_id: 'personal-board',
+      personal_list_id: 'list-1',
+      source_board_id: null,
+      source_list_id: null,
+      source_workspace_id: null,
+    } as Partial<Task>);
+
+    expect(usesPersonalPlacement(personalTask)).toBe(false);
+  });
+
+  it('does not treat an explicitly native personal task as external when source metadata is present', () => {
+    const personalTask = createTask({
+      is_personal_external: false,
+      personal_board_id: 'personal-board',
+      personal_list_id: 'list-1',
+      source_workspace_id: 'personal-workspace',
+      source_board_id: 'personal-board',
+      source_list_id: 'list-1',
+    } as Partial<Task>);
+
+    expect(usesPersonalPlacement(personalTask)).toBe(false);
+  });
+
+  it('does not treat same-board personal metadata as external without an explicit flag', () => {
+    const personalTask = createTask({
+      is_personal_external: undefined,
+      personal_board_id: 'personal-board',
+      personal_list_id: 'list-1',
+      source_workspace_id: 'personal-workspace',
+      source_board_id: 'personal-board',
+      source_list_id: 'list-1',
+    } as Partial<Task>);
+
+    expect(usesPersonalPlacement(personalTask)).toBe(false);
+  });
+
+  it('keeps explicit external overlays on the personal-placement path', () => {
+    expect(usesPersonalPlacement(createTask())).toBe(true);
+  });
+});
+
 describe('mergeTaskIntoBoardTaskCache', () => {
   it('updates an existing task in the board cache', () => {
     const existingTask = createTask({ list_id: 'source-list' });

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

@@ -21,6 +21,7 @@ import {
 } from '@tuturuuu/utils/task-helper';
 import { hasDraggableData } from '@tuturuuu/utils/task-helpers';
 import { useCallback, useRef, useState } from 'react';
+import { isPersonalExternalOverlayTask } from '../../../../../../../lib/task-personal-external';
 import { useBoardBroadcast } from '../../../../shared/board-broadcast-context';
 import { invalidateKanbanDeadlineTasks } from '../data/kanban-deadline-query';
 import { MAX_SAFE_INTEGER_SORT } from '../kanban-constants';
@@ -121,12 +122,8 @@ interface UseKanbanDndProps {
   scrollContainerRef: React.RefObject<HTMLDivElement | null>;
 }
 
-function usesPersonalPlacement(task: Task) {
-  return (
-    task.is_personal_external === true ||
-    Boolean(task.personal_board_id) ||
-    isPersonalExternalStagingListId(task.list_id)
-  );
+export function usesPersonalPlacement(task: Task) {
+  return isPersonalExternalOverlayTask(task);
 }
 
 function getTaskDropPosition(

package/src/components/ui/tu-do/boards/boardId/task-card/task-card-open-options.test.ts

@@ -76,7 +76,7 @@ describe('getTaskCardHydratingOpenOptions', () => {
       taskWsId: 'source-workspace',
       taskWorkspacePersonal: false,
       canUseBoardAssignees: true,
-      assigneeMemberSource: 'workspace',
+      assigneeMemberSource: 'board',
       initialSharedContext: {
         boardConfig: {
           id: 'source-board',
@@ -151,4 +151,14 @@ describe('getTaskCardHydratingOpenOptions', () => {
     ).toBe(true);
     expect(isExternalTaskSnapshot(task)).toBe(false);
   });
+
+  it('does not treat personal placement metadata alone as an external snapshot', () => {
+    expect(
+      isExternalTaskSnapshot({
+        ...task,
+        personal_board_id: 'board-1',
+        personal_list_id: 'list-1',
+      })
+    ).toBe(false);
+  });
 });

package/src/components/ui/tu-do/boards/boardId/task-card/task-card-open-options.ts

@@ -1,5 +1,6 @@
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
+import { isPersonalExternalOverlayTask } from '../../../../../../lib/task-personal-external';
 import type { SharedTaskContext } from '../../../shared/task-edit-dialog/hooks/use-task-data';
 
 interface TaskCardOpenOptionsInput {
@@ -13,9 +14,12 @@ interface TaskCardOpenOptionsInput {
 }
 
 export function isExternalTaskSnapshot(task: Task) {
+  if (task.is_personal_external === false) {
+    return false;
+  }
+
   return (
-    task.is_personal_external === true ||
-    Boolean(task.personal_board_id) ||
+    isPersonalExternalOverlayTask(task) ||
     Boolean(task.source_workspace_id) ||
     Boolean(task.source_board_id)
   );
@@ -131,7 +135,7 @@ export function getTaskCardHydratingOpenOptions({
     taskWorkspacePersonal: sourceWorkspaceId ? false : isPersonalWorkspace,
     canUseBoardAssignees: canUseBoardAssignees ?? sourceBoardAssigneesEnabled,
     assigneeMemberSource:
-      assigneeMemberSource ?? (sourceWorkspaceId ? 'workspace' : undefined),
+      assigneeMemberSource ?? (sourceWorkspaceId ? 'board' : undefined),
     initialSharedContext,
   };
 }

package/src/components/ui/tu-do/boards/boardId/task-card/task-card-resource-context.test.ts

@@ -0,0 +1,113 @@
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
+import { describe, expect, it } from 'vitest';
+import { getTaskCardResourceContext } from './task-card-resource-context';
+
+const pageList = {
+  id: 'page-list',
+  name: 'Page list',
+  board_id: 'page-board',
+  position: 0,
+  status: 'not_started',
+  color: 'BLUE',
+  created_at: '2026-07-04T00:00:00.000Z',
+  creator_id: 'user-1',
+  archived: false,
+  deleted: false,
+} satisfies TaskList;
+
+const task = {
+  id: 'task-1',
+  name: 'Task',
+  description: '',
+  list_id: 'page-list',
+  display_number: 1,
+  created_at: '2026-07-04T00:00:00.000Z',
+  end_date: null,
+  priority: 'normal',
+} satisfies Task;
+
+describe('getTaskCardResourceContext', () => {
+  it('keeps local task resources on the page workspace and board', () => {
+    expect(
+      getTaskCardResourceContext({
+        boardId: 'page-board',
+        pageWorkspaceId: 'page-workspace',
+        propAvailableLists: [pageList],
+        task,
+      })
+    ).toEqual({
+      boardViewableMembersBoardId: 'page-board',
+      boardViewableMembersWorkspaceId: 'page-workspace',
+      effectiveWorkspaceId: 'page-workspace',
+      initialAvailableLists: [pageList],
+      isSourceWorkspaceTask: false,
+      taskBoardId: 'page-board',
+    });
+  });
+
+  it('routes source task labels, projects, lists, and members to the source workspace and board', () => {
+    expect(
+      getTaskCardResourceContext({
+        boardId: 'personal-board',
+        pageWorkspaceId: 'personal-workspace',
+        propAvailableLists: [pageList],
+        task: {
+          ...task,
+          list_id: 'personal-list',
+          source_board_id: 'source-board',
+          source_workspace_id: 'source-workspace',
+        },
+      })
+    ).toEqual({
+      boardViewableMembersBoardId: 'source-board',
+      boardViewableMembersWorkspaceId: 'source-workspace',
+      effectiveWorkspaceId: 'source-workspace',
+      initialAvailableLists: undefined,
+      isSourceWorkspaceTask: true,
+      taskBoardId: 'source-board',
+    });
+  });
+
+  it('uses the page workspace when a source board is present without source workspace metadata', () => {
+    expect(
+      getTaskCardResourceContext({
+        boardId: 'page-board',
+        pageWorkspaceId: 'page-workspace',
+        propAvailableLists: [pageList],
+        task: {
+          ...task,
+          source_board_id: 'source-board',
+        },
+      })
+    ).toMatchObject({
+      boardViewableMembersBoardId: 'source-board',
+      boardViewableMembersWorkspaceId: 'page-workspace',
+      effectiveWorkspaceId: 'page-workspace',
+      initialAvailableLists: undefined,
+      isSourceWorkspaceTask: true,
+      taskBoardId: 'source-board',
+    });
+  });
+
+  it('keeps page board list data when only source workspace metadata is available', () => {
+    expect(
+      getTaskCardResourceContext({
+        boardId: 'page-board',
+        pageWorkspaceId: 'page-workspace',
+        propAvailableLists: [pageList],
+        task: {
+          ...task,
+          source_workspace_id: 'source-workspace',
+        },
+      })
+    ).toMatchObject({
+      boardViewableMembersBoardId: 'page-board',
+      boardViewableMembersWorkspaceId: 'source-workspace',
+      effectiveWorkspaceId: 'source-workspace',
+      initialAvailableLists: [pageList],
+      isSourceWorkspaceTask: true,
+      taskBoardId: 'page-board',
+    });
+  });
+});

package/src/components/ui/tu-do/boards/boardId/task-card/task-card-resource-context.ts

@@ -0,0 +1,50 @@
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
+
+export interface TaskCardResourceContextInput {
+  boardId: string;
+  pageWorkspaceId?: string;
+  propAvailableLists?: TaskList[];
+  task: Task;
+}
+
+export interface TaskCardResourceContext {
+  boardViewableMembersBoardId: string;
+  boardViewableMembersWorkspaceId?: string;
+  effectiveWorkspaceId?: string;
+  initialAvailableLists?: TaskList[];
+  isSourceWorkspaceTask: boolean;
+  taskBoardId: string;
+}
+
+export function getTaskCardResourceContext({
+  boardId,
+  pageWorkspaceId,
+  propAvailableLists,
+  task,
+}: TaskCardResourceContextInput): TaskCardResourceContext {
+  const effectiveWorkspaceId = task.source_workspace_id ?? pageWorkspaceId;
+  const taskBoardId = task.source_board_id ?? boardId;
+  const isSourceWorkspaceTask = Boolean(
+    task.source_workspace_id || task.source_board_id
+  );
+  const boardViewableMembersWorkspaceId =
+    task.source_workspace_id ?? pageWorkspaceId;
+  const boardViewableMembersBoardId =
+    isSourceWorkspaceTask && task.source_board_id
+      ? task.source_board_id
+      : boardId;
+  const initialAvailableLists =
+    isSourceWorkspaceTask && task.source_board_id
+      ? undefined
+      : propAvailableLists;
+
+  return {
+    boardViewableMembersBoardId,
+    boardViewableMembersWorkspaceId,
+    effectiveWorkspaceId,
+    initialAvailableLists,
+    isSourceWorkspaceTask,
+    taskBoardId,
+  };
+}

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

@@ -33,6 +33,7 @@ import {
   listWorkspaceTaskBoardViewableMembers,
   listWorkspaceTaskLists,
   listWorkspaceTaskProjects,
+  listWorkspaceTaskProjectsByIds,
   removeCurrentUserTaskPersonalPlacement,
 } from '@tuturuuu/internal-api/tasks';
 import type { SupportedColor } from '@tuturuuu/types/primitives/SupportedColors';
@@ -85,6 +86,7 @@ import React, {
   useRef,
   useState,
 } from 'react';
+import { isPersonalExternalOverlayTask } from '../../../../../../lib/task-personal-external';
 import {
   enqueueTaskCardRelationshipRequest,
   useTaskCardRelationships,
@@ -153,6 +155,7 @@ import {
   getTaskCardHydratingOpenOptions,
   isExternalTaskSnapshot,
 } from './task-card-open-options';
+import { getTaskCardResourceContext } from './task-card-resource-context';
 import { getTaskCardVisibilityState } from './task-card-visibility';
 import { TaskSchedulingBadge } from './task-scheduling-badge';
 
@@ -390,7 +393,24 @@ function TaskCardInner({
   // Use React Query hooks for shared data (cached across all task cards)
   const workspaceContextWsId = workspaceId ?? wsId;
   const { data: boardConfig } = useBoardConfig(boardId, workspaceContextWsId);
-  const effectiveWorkspaceId = workspaceId ?? boardConfig?.ws_id ?? wsId;
+  const pageWorkspaceId = workspaceId ?? boardConfig?.ws_id ?? wsId;
+  const {
+    boardViewableMembersBoardId,
+    boardViewableMembersWorkspaceId,
+    effectiveWorkspaceId,
+    initialAvailableLists,
+    isSourceWorkspaceTask,
+    taskBoardId,
+  } = getTaskCardResourceContext({
+    boardId,
+    pageWorkspaceId,
+    propAvailableLists,
+    task,
+  });
+  const taskProjectIds = useMemo(
+    () => task.projects?.map((project) => project.id).filter(Boolean) ?? [],
+    [task.projects]
+  );
   const taskShareWsId = effectiveWorkspaceId;
   const { data: workspaceLabels = [], isLoading: labelsLoading } =
     useWorkspaceLabels(effectiveWorkspaceId);
@@ -431,12 +451,24 @@ function TaskCardInner({
   // Fetch workspace projects
   const { data: workspaceProjects = [], isLoading: projectsLoading } = useQuery(
     {
-      queryKey: ['task_projects', effectiveWorkspaceId],
+      queryKey: [
+        'task_projects',
+        effectiveWorkspaceId,
+        isSourceWorkspaceTask ? taskProjectIds.join(',') : 'all',
+      ],
       queryFn: async () => {
         if (!effectiveWorkspaceId) return [];
+        if (isSourceWorkspaceTask) {
+          return listWorkspaceTaskProjectsByIds(
+            effectiveWorkspaceId,
+            taskProjectIds
+          );
+        }
         return listWorkspaceTaskProjects(effectiveWorkspaceId);
       },
-      enabled: !!effectiveWorkspaceId,
+      enabled:
+        !!effectiveWorkspaceId &&
+        (!isSourceWorkspaceTask || taskProjectIds.length > 0),
       staleTime: 5 * 60 * 1000, // 5 minutes - projects rarely change
     }
   );
@@ -470,27 +502,35 @@ function TaskCardInner({
     enabled: !!effectiveWorkspaceId && shouldLoadWorkspaceMembers,
   });
   const boardViewableMembersQuery = useQuery({
-    queryKey: ['task-board-viewable-members', effectiveWorkspaceId, boardId],
+    queryKey: [
+      'task-board-viewable-members',
+      boardViewableMembersWorkspaceId,
+      boardViewableMembersBoardId,
+    ],
     queryFn: async (): Promise<WorkspaceMember[]> => {
-      if (!effectiveWorkspaceId || !boardId) return [];
+      if (!boardViewableMembersWorkspaceId || !boardViewableMembersBoardId) {
+        return [];
+      }
 
       const payload = await listWorkspaceTaskBoardViewableMembers(
-        effectiveWorkspaceId,
-        boardId
+        boardViewableMembersWorkspaceId,
+        boardViewableMembersBoardId
       );
       const members = Array.isArray(payload?.members) ? payload.members : [];
 
       return members.map((member) => ({
         id: member.user_id,
         user_id: member.user_id,
-        workspace_id: effectiveWorkspaceId,
+        workspace_id: boardViewableMembersWorkspaceId,
         display_name: member.display_name ?? member.email ?? member.user_id,
         email: member.email ?? undefined,
         avatar_url: member.avatar_url ?? undefined,
       }));
     },
     enabled:
-      !!effectiveWorkspaceId && !!boardId && shouldLoadBoardViewableMembers,
+      !!boardViewableMembersWorkspaceId &&
+      !!boardViewableMembersBoardId &&
+      shouldLoadBoardViewableMembers,
     staleTime: 5 * 60 * 1000,
   });
   const normalWorkspaceMembers = normalMembersQuery.data ?? [];
@@ -717,15 +757,15 @@ function TaskCardInner({
 
   // Fetch available task lists using React Query (same key as other components)
   const { data: availableLists = [] } = useQuery({
-    queryKey: ['task_lists', boardId],
+    queryKey: ['task_lists', taskBoardId],
     queryFn: async () => {
-      if (!effectiveWorkspaceId) {
+      if (!effectiveWorkspaceId || !taskBoardId) {
         return [];
       }
 
       const { lists } = await listWorkspaceTaskLists(
         effectiveWorkspaceId,
-        boardId,
+        taskBoardId,
         typeof window !== 'undefined'
           ? { baseUrl: window.location.origin }
           : undefined
@@ -733,8 +773,8 @@ function TaskCardInner({
 
       return lists.filter((list) => !list.deleted) as TaskList[];
     },
-    enabled: !propAvailableLists && !!effectiveWorkspaceId, // Only fetch if not provided as prop
-    initialData: propAvailableLists,
+    enabled: !initialAvailableLists && !!effectiveWorkspaceId && !!taskBoardId,
+    initialData: initialAvailableLists,
     staleTime: 60 * 1000, // 1 minute - lists change less frequently
   });
 
@@ -852,6 +892,7 @@ function TaskCardInner({
   // Check if task is optimistically added (pending realtime confirmation)
   const isOptimistic = '_isOptimistic' in task && task._isOptimistic === true;
   const isPersonalExternalTask = isExternalTaskSnapshot(task);
+  const isPersonalExternalOverlay = isPersonalExternalOverlayTask(task);
   const sourceBoardUrl =
     task.source_workspace_id && task.source_board_id
       ? `/${task.source_workspace_id}${tasksHref(`/boards/${task.source_board_id}`)}`
@@ -1098,7 +1139,7 @@ function TaskCardInner({
           ? true
           : shouldUseBoardAssignees,
         assigneeMemberSource: task.source_workspace_id
-          ? 'workspace'
+          ? 'board'
           : effectiveAssigneeMemberSource,
         effectiveWorkspaceId,
         isPersonalWorkspace,
@@ -1201,7 +1242,13 @@ function TaskCardInner({
   const handleAddSubtask = () => {
     setMenuOpen(false);
     // Open subtask creation dialog - the relationship will be created when the user saves
-    createSubtask(task.id, task.name, boardId, task.list_id, availableLists);
+    createSubtask(
+      task.id,
+      task.name,
+      taskBoardId,
+      task.list_id,
+      availableLists
+    );
   };
 
   const handleMoveToExternalStaging = async () => {
@@ -2303,7 +2350,7 @@ function TaskCardInner({
                     />
                   )}
 
-                  {isPersonalExternalTask && (
+                  {isPersonalExternalOverlay && (
                     <>
                       {task.personal_board_id && task.personal_list_id && (
                         <DropdownMenuItem
@@ -2715,7 +2762,7 @@ function TaskCardInner({
         <CreateListDialog
           open={isCreateListDialogOpen}
           onOpenChange={setIsCreateListDialogOpen}
-          boardId={boardId}
+          boardId={taskBoardId}
           wsId={effectiveWorkspaceId}
           initialStatus="active"
           onSuccess={(listId) => {

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

@@ -254,7 +254,7 @@ export function TimelineBoard({
               ? true
               : showAssignees,
             assigneeMemberSource: task.source_workspace_id
-              ? 'workspace'
+              ? 'board'
               : effectiveAssigneeMemberSource,
           })
         );

package/src/components/ui/tu-do/cycles/task-cycles-client.tsx

@@ -47,6 +47,7 @@ import { toast } from '@tuturuuu/ui/sonner';
 import { Textarea } from '@tuturuuu/ui/textarea';
 import dayjs from 'dayjs';
 import { useCallback, useEffect, useMemo, useState } from 'react';
+import { getTaskApiUrl } from '../../../../lib/tasks-app-url';
 
 type CycleStatus = 'planned' | 'active' | 'completed' | 'cancelled';
 
@@ -128,7 +129,9 @@ export function TaskCyclesClient({
   } = useQuery<TaskCycle[]>({
     queryKey: ['workspace', wsId, 'task-cycles'],
     queryFn: async () => {
-      const response = await fetch(`/api/v1/workspaces/${wsId}/task-cycles`);
+      const response = await fetch(
+        getTaskApiUrl(`/api/v1/workspaces/${wsId}/task-cycles`)
+      );
       if (!response.ok) throw new Error('Failed to fetch cycles');
       return response.json();
     },
@@ -149,17 +152,21 @@ export function TaskCyclesClient({
       start_date?: string | null;
       end_date?: string | null;
     }) => {
-      const response = await fetch(`/api/v1/workspaces/${wsId}/task-cycles`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          name,
-          description,
-          status,
-          start_date,
-          end_date,
-        }),
-      });
+      const response = await fetch(
+        getTaskApiUrl(`/api/v1/workspaces/${wsId}/task-cycles`),
+        {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            name,
+            description,
+            status,
+            start_date,
+            end_date,
+          }),
+        }
+      );
       if (!response.ok) {
         const data = await response.json();
         throw new Error(data.error || 'Failed to create cycle');
@@ -196,9 +203,10 @@ export function TaskCyclesClient({
       end_date?: string | null;
     }) => {
       const response = await fetch(
-        `/api/v1/workspaces/${wsId}/task-cycles/${id}`,
+        getTaskApiUrl(`/api/v1/workspaces/${wsId}/task-cycles/${id}`),
         {
           method: 'PUT',
+          credentials: 'include',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({
             name,
@@ -232,9 +240,10 @@ export function TaskCyclesClient({
   const deleteMutation = useMutation({
     mutationFn: async (id: string) => {
       const response = await fetch(
-        `/api/v1/workspaces/${wsId}/task-cycles/${id}`,
+        getTaskApiUrl(`/api/v1/workspaces/${wsId}/task-cycles/${id}`),
         {
           method: 'DELETE',
+          credentials: 'include',
         }
       );
       if (!response.ok) {

package/src/components/ui/tu-do/estimates/use-task-estimates.ts

@@ -3,6 +3,7 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import type { WorkspaceTaskBoard } from '@tuturuuu/types';
 import { useTranslations } from 'next-intl';
+import { getTaskApiUrl } from '../../../../lib/tasks-app-url';
 
 export interface TaskEstimateBoardsResponse {
   boards: Partial<WorkspaceTaskBoard>[];
@@ -34,9 +35,12 @@ export const taskEstimateBoardKeys = {
 export async function fetchTaskEstimateBoards(
   wsId: string
 ): Promise<TaskEstimateBoardsResponse> {
-  const response = await fetch(`/api/v1/workspaces/${wsId}/boards/estimation`, {
-    cache: 'no-store',
-  });
+  const response = await fetch(
+    getTaskApiUrl(`/api/v1/workspaces/${wsId}/boards/estimation`),
+    {
+      cache: 'no-store',
+    }
+  );
 
   if (!response.ok) {
     throw new Error('Failed to fetch task estimate boards');
@@ -56,9 +60,10 @@ async function updateTaskEstimateBoard(
   }: UpdateTaskEstimateBoardInput
 ) {
   const response = await fetch(
-    `/api/v1/workspaces/${wsId}/boards/${boardId}/estimation`,
+    getTaskApiUrl(`/api/v1/workspaces/${wsId}/boards/${boardId}/estimation`),
     {
       cache: 'no-store',
+      credentials: 'include',
       method: 'PATCH',
       headers: {
         'Content-Type': 'application/json',

package/src/components/ui/tu-do/habits/client.tsx

@@ -14,6 +14,7 @@ import {
 import { Skeleton } from '@tuturuuu/ui/skeleton';
 import { toast } from '@tuturuuu/ui/sonner';
 import { useState } from 'react';
+import { getTaskApiUrl } from '../../../../lib/tasks-app-url';
 import HabitCard from './habit-card';
 import HabitFormDialog from './habit-form-dialog';
 
@@ -39,7 +40,9 @@ export default function HabitsClientPage({ wsId }: HabitsClientPageProps) {
   } = useQuery({
     queryKey: ['habits', wsId],
     queryFn: async () => {
-      const response = await fetch(`/api/v1/workspaces/${wsId}/habits`);
+      const response = await fetch(
+        getTaskApiUrl(`/api/v1/workspaces/${wsId}/habits`)
+      );
       if (!response.ok) {
         throw new Error('Failed to fetch habits');
       }