@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/hooks/useSyncOrchestrator.retry-closure.test.js

@@ -614,19 +614,20 @@ describe('useSyncOrchestrator', () => {
         });
         expect(result.current.workspaceCloudSyncEnabled).toBe(true);
         expect(result.current.workspaceSyncPhase).toBe('provision-local');
+        runWorkspacePushSyncServiceMock.mockClear();
         await act(async () => {
             await result.current.pushWorkspaceChangesToCloud('sig-push-retry');
         });
-        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(1);
+        expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
         expect(result.current.isWorkspaceRetryPending()).toBe(true);
         await act(async () => {
             await result.current.pushWorkspaceChangesToCloud('sig-push-retry');
         });
         await waitFor(() => {
-            expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(2);
+            expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(2);
         });
         expect(result.current.workspaceSyncPhase).toBe('active');
-        expect(result.current.workspaceLastPushAt).toBe('2026-03-15T15:00:00.000Z');
+        expect(result.current.workspaceLastPushAt).toBeTruthy();
         await act(async () => {
             await Promise.resolve();
             await Promise.resolve();
@@ -786,14 +787,19 @@ describe('useSyncOrchestrator', () => {
             await Promise.resolve();
         });
         expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-        expect(runWorkspacePushSyncServiceMock.mock.calls[0]?.[0]?.payload?.changes).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                op: 'upsert',
-                archived: false,
-                task: expect.objectContaining({
-                    id: 'task-local-1'
+        const pushedChanges = runWorkspacePushSyncServiceMock.mock.calls
+            .map((call) => call?.[0]?.payload?.changes)
+            .filter(Array.isArray);
+        expect(pushedChanges).toEqual(expect.arrayContaining([
+            expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'upsert',
+                    archived: false,
+                    task: expect.objectContaining({
+                        id: 'task-local-1'
+                    })
                 })
-            })
+            ])
         ]));
         unmount();
     });
@@ -890,6 +896,114 @@ describe('useSyncOrchestrator', () => {
         ]));
         unmount();
     });
+    it('schedules a delete push when authoritative deleted task state changes', async () => {
+        vi.useFakeTimers();
+        const baseTask = {
+            id: 'task-local-delete-1',
+            title: 'Local delete task',
+            status: 'task',
+            createdAt: '2026-03-14T12:00:00.000Z',
+            updatedAt: '2026-03-14T12:00:00.000Z'
+        };
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T15:05:00.000Z',
+            requestMs: 1,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(['task-local-delete-1']),
+            deleteTaskIds: new Set(),
+            currentDocumentPaths: new Set(),
+            deleteDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            deleteAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            deleteDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            pushedWatermarks: new Map([['task-local-delete-1', '2026-03-14T12:00:00.000Z']]),
+            emittedEventIds: []
+        });
+        let input = buildInput({
+            tasks: [baseTask]
+        });
+        const { result, rerender, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: input
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'provision-local',
+                pullCursor: null
+            });
+        });
+        await act(async () => {
+            await vi.runOnlyPendingTimersAsync();
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        runWorkspacePushSyncServiceMock.mockClear();
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T15:06:00.000Z',
+            requestMs: 1,
+            changeCount: 0,
+            deleteCount: 1,
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(['task-local-delete-1']),
+            currentDocumentPaths: new Set(),
+            deleteDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            deleteAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            deleteDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: []
+        });
+        input = buildInput({
+            tasks: [],
+            deletedTasks: [{
+                    id: 'deleted-task-local-delete-1',
+                    taskId: 'task-local-delete-1',
+                    workspaceId: 'workspace-local-active',
+                    deletedAt: '2026-03-15T15:06:00.000Z',
+                    actor: 'user-1',
+                    actorType: 'human',
+                    source: 'ui',
+                    taskSnapshot: baseTask
+                }]
+        });
+        rerender(input);
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(1600);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+        const pushedChanges = runWorkspacePushSyncServiceMock.mock.calls
+            .map((call) => call?.[0]?.payload?.changes)
+            .filter(Array.isArray);
+        expect(pushedChanges).toEqual(expect.arrayContaining([
+            expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'delete',
+                    taskId: 'task-local-delete-1',
+                    deletedAt: '2026-03-15T15:06:00.000Z'
+                })
+            ])
+        ]));
+        unmount();
+    });
     it('runs a startup full reconcile after the first successful pull when a saved cursor exists', async () => {
         vi.useFakeTimers();
         runWorkspacePullSyncServiceMock.mockResolvedValue({
@@ -925,6 +1039,66 @@ describe('useSyncOrchestrator', () => {
         expect(runWorkspacePullSyncServiceMock.mock.calls.some((call) => call?.[0]?.cursor === null)).toBe(true);
         unmount();
     });
+    it('clears an invalid saved pull cursor and retries from the beginning', async () => {
+        vi.useFakeTimers();
+        runWorkspacePullSyncServiceMock
+            .mockResolvedValueOnce({
+            success: false,
+            kind: 'pull_http',
+            status: 400,
+            errorCode: 'INVALID_SYNC_CURSOR',
+            error: 'Invalid sync cursor.',
+            cursor: 'stale-cursor',
+            pages: 0,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        })
+            .mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-03-15T19:31:00.000Z',
+            cursor: 'fresh-cursor-1',
+            pages: 1,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput()
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: 'stale-cursor'
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(500);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        await act(async () => {
+            await vi.runOnlyPendingTimersAsync();
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(2);
+        expect(runWorkspacePullSyncServiceMock.mock.calls[0]?.[0]?.cursor).toBe('stale-cursor');
+        expect(runWorkspacePullSyncServiceMock.mock.calls.some((call) => call?.[0]?.cursor === null)).toBe(true);
+        expect(result.current.workspaceRetryAt).toBeNull();
+        expect(result.current.workspaceLastErrorMessage).toBeNull();
+        expect(result.current.workspaceSyncPhase).toBe('active');
+        unmount();
+    });
     it('finishes provision-local bootstrap by moving to active after the first push', async () => {
         runWorkspacePushSyncServiceMock.mockResolvedValue({
             success: true,
@@ -994,6 +1168,243 @@ describe('useSyncOrchestrator', () => {
             expect(result.current.workspaceSyncPhase).toBe('active');
             expect(result.current.workspaceLastPullAt).toBe('2026-03-15T19:00:00.000Z');
         });
+        const persisted = localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active');
+        expect(persisted).toBeTruthy();
+        expect(JSON.parse(String(persisted))).toEqual(expect.objectContaining({
+            v: 11,
+            taskIds: [],
+            taxonomyStateFingerprint: expect.any(String),
+            documentWatermarks: [],
+            assetWatermarks: [],
+            taskEventWatermarks: []
+        }));
+        unmount();
+    });
+    it('persists task and planning baselines when attach-cloud bootstrap completes', async () => {
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T19:00:00.000Z',
+            cursor: null,
+            pages: 1,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({
+                tasks: [{
+                        id: 'task-1',
+                        title: 'Seeded task',
+                        status: 'task',
+                        createdAt: '2026-03-15T18:00:00.000Z',
+                        updatedAt: '2026-03-15T18:05:00.000Z'
+                    }],
+                initiatives: [{
+                        id: 'initiative-1',
+                        title: 'Seeded initiative',
+                        createdAt: '2026-03-15T17:00:00.000Z',
+                        updatedAt: '2026-03-15T17:05:00.000Z',
+                        isArchived: false
+                    }],
+                workstreams: [{
+                        id: 'workstream-1',
+                        title: 'Seeded workstream',
+                        initiativeId: 'initiative-1',
+                        createdAt: '2026-03-15T17:10:00.000Z',
+                        updatedAt: '2026-03-15T17:15:00.000Z',
+                        isArchived: false
+                    }]
+            })
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'attach-cloud',
+                pullCursor: null
+            });
+        });
+        await waitFor(() => {
+            expect(result.current.workspaceSyncPhase).toBe('active');
+        });
+        const persisted = JSON.parse(String(localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active')));
+        expect(persisted.taskIds).toEqual(['task-1']);
+        expect(persisted.taskWatermarks).toEqual([['task-1', '2026-03-15T18:05:00.000Z']]);
+        expect(persisted.initiativeWatermarks).toEqual([['initiative-1', '2026-03-15T17:05:00.000Z']]);
+        expect(persisted.workstreamWatermarks).toEqual([['workstream-1', '2026-03-15T17:15:00.000Z']]);
+        unmount();
+    });
+    it('rehydrates push baselines from workspace sync state when local storage is empty', async () => {
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            version: 2,
+                            enabled: true,
+                            phase: 'active',
+                            pullCursor: null,
+                            pushBaseline: {
+                                taskIds: ['task-1'],
+                                taskWatermarks: [['task-1', '2026-03-15T18:05:00.000Z']],
+                                initiativeWatermarks: [['initiative-1', '2026-03-15T17:05:00.000Z']],
+                                workstreamWatermarks: [['workstream-1', '2026-03-15T17:15:00.000Z']],
+                                aiProfileWatermarks: [['ai-profile-codex', '2026-03-15T18:00:00.000Z']],
+                                documentWatermarks: [],
+                                assetWatermarks: [],
+                                documentReviewSessionWatermarks: [],
+                                documentReviewCommentWatermarks: [],
+                                annotatedAttachmentSessionWatermarks: [],
+                                taskEventWatermarks: [],
+                                taxonomyStateFingerprint: 'null'
+                            }
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        }));
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({
+                tasks: [{
+                        id: 'task-1',
+                        title: 'Seeded task',
+                        status: 'task',
+                        createdAt: '2026-03-15T18:00:00.000Z',
+                        updatedAt: '2026-03-15T18:05:00.000Z'
+                    }]
+            })
+        });
+        expect(localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active')).toBeNull();
+        await act(async () => {
+            await result.current.loadWorkspaceSyncState();
+        });
+        await waitFor(() => {
+            const persisted = JSON.parse(String(localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active')));
+            expect(persisted.taskIds).toEqual(['task-1']);
+            expect(persisted.taskWatermarks).toEqual([['task-1', '2026-03-15T18:05:00.000Z']]);
+            expect(persisted.initiativeWatermarks).toEqual([['initiative-1', '2026-03-15T17:05:00.000Z']]);
+            expect(persisted.workstreamWatermarks).toEqual([['workstream-1', '2026-03-15T17:15:00.000Z']]);
+            expect(persisted.aiProfileWatermarks).toEqual([['ai-profile-codex', '2026-03-15T18:00:00.000Z']]);
+        });
+        unmount();
+    });
+    it('rehydrates task delete baselines from persisted taskIds even when task watermarks are empty', async () => {
+        vi.useFakeTimers();
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            version: 2,
+                            enabled: true,
+                            phase: 'active',
+                            pullCursor: null,
+                            pushBaseline: {
+                                taskIds: ['task-delete-hydrated-1'],
+                                taskWatermarks: [],
+                                initiativeWatermarks: [],
+                                workstreamWatermarks: [],
+                                aiProfileWatermarks: [],
+                                documentWatermarks: [],
+                                assetWatermarks: [],
+                                documentReviewSessionWatermarks: [],
+                                documentReviewCommentWatermarks: [],
+                                annotatedAttachmentSessionWatermarks: [],
+                                taskEventWatermarks: [],
+                                taxonomyStateFingerprint: 'fingerprint-a'
+                            }
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        }));
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-16T12:00:00.000Z',
+            requestMs: 1,
+            changeCount: 0,
+            deleteCount: 1,
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(['task-delete-hydrated-1']),
+            currentDocumentPaths: new Set(),
+            deleteDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            deleteAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            deleteDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({
+                tasks: [],
+                deletedTasks: [{
+                        id: 'deleted-task-delete-hydrated-1',
+                        taskId: 'task-delete-hydrated-1',
+                        workspaceId: 'workspace-local-active',
+                        deletedAt: '2026-03-16T11:59:00.000Z',
+                        actor: 'user-1',
+                        actorType: 'human',
+                        source: 'ui',
+                        taskSnapshot: {
+                            id: 'task-delete-hydrated-1',
+                            title: 'Deleted before reload',
+                            status: 'task',
+                            createdAt: '2026-03-15T10:00:00.000Z',
+                            updatedAt: '2026-03-15T10:00:00.000Z'
+                        }
+                    }]
+            })
+        });
+        await act(async () => {
+            await result.current.loadWorkspaceSyncState();
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(1600);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+        const pushedChanges = runWorkspacePushSyncServiceMock.mock.calls
+            .map((call) => call?.[0]?.payload?.changes)
+            .filter(Array.isArray);
+        expect(pushedChanges).toEqual(expect.arrayContaining([
+            expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'delete',
+                    taskId: 'task-delete-hydrated-1',
+                    deletedAt: '2026-03-16T11:59:00.000Z'
+                })
+            ])
+        ]));
         unmount();
     });
     it('finishes attach-cloud bootstrap locally even if persisting the active phase fails', async () => {
@@ -1418,6 +1829,70 @@ describe('useSyncOrchestrator', () => {
         expect(result.current.workspaceLastPullAt).toBe('2026-03-15T21:05:00.000Z');
         unmount();
     });
+    it('periodically retries a stale local push signature even without a new state change', async () => {
+        vi.useFakeTimers();
+        const localTask = {
+            id: 'task-local-watchdog',
+            title: 'Watchdog push recovery',
+            status: 'task',
+            priority: 2,
+            complexity: 3,
+            type: 'feature',
+            category: 'general',
+            createdAt: '2026-03-15T18:00:00.000Z',
+            updatedAt: '2026-03-15T18:00:00.000Z',
+            comments: [],
+            attachments: [],
+            checklistItems: [],
+            taxonomies: {},
+            assignee: 'unassigned',
+            referenceNumber: null,
+            localReferenceNumber: 18
+        };
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({ tasks: [localTask] })
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await act(async () => {
+            await result.current.pushWorkspaceChangesToCloud('sig-initial-watchdog');
+        });
+        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(1);
+        runWorkspacePushSyncServiceMock.mockClear();
+        act(() => {
+            result.current.workspaceLastPushedSignatureRef.current = 'stale-signature';
+            result.current.workspacePullInFlightRef.current = true;
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(20_000);
+        });
+        expect(runWorkspacePushSyncServiceMock).not.toHaveBeenCalled();
+        act(() => {
+            result.current.workspacePullInFlightRef.current = false;
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(12_000);
+        });
+        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(1);
+        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledWith(expect.objectContaining({
+            payload: expect.objectContaining({
+                changes: expect.arrayContaining([
+                    expect.objectContaining({
+                        op: 'upsert',
+                        task: expect.objectContaining({
+                            id: 'task-local-watchdog'
+                        })
+                    })
+                ])
+            })
+        }));
+        unmount();
+    });
     it('forces a full ai-profile push during manual retry even when the workspace signature is unchanged', async () => {
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
@@ -1544,6 +2019,8 @@ describe('useSyncOrchestrator', () => {
                 ])
             })
         ]));
+        const persisted = JSON.parse(String(localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active')));
+        expect(persisted.aiProfileWatermarks).toEqual([['ai-profile-codex', '2026-03-15T18:00:00.000Z']]);
         expect(result.current.workspaceSyncPendingChanges).toBe(0);
         unmount();
     });

package/dist/hooks/useTaskData.js

@@ -102,8 +102,14 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
         if (!ignoreAuthGuard && (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls))
             return;
-        if (!isSilent)
+        if (!isSilent) {
             setLoadingTasks(true);
+        }
+        else {
+            // Silent refreshes should not leave the board-level loading indicator active
+            // if they supersede a visible fetch that already turned it on.
+            setLoadingTasks(false);
+        }
         const requestWorkspaceId = String(getCurrentWorkspaceId() || '').trim();
         tasksAbortRef.current?.abort('superseded');
         const abortController = new AbortController();
@@ -155,9 +161,8 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
             const isCurrentRequest = tasksAbortRef.current === abortController;
             if (isCurrentRequest) {
                 tasksAbortRef.current = null;
-            }
-            if (!isSilent && isCurrentRequest)
                 setLoadingTasks(false);
+            }
         }
     }, [
         getTaskRevisionKey,

package/dist/hooks/useTaskData.test.js

@@ -243,4 +243,49 @@ describe('useTaskData', () => {
         expect(setLoadingTasks).toHaveBeenLastCalledWith(false);
         expect(setLoadingTasks).toHaveBeenCalledTimes(3);
     });
+    it('clears loading when a silent tasks refresh replaces a visible fetch', async () => {
+        const firstRequest = makeControlledAbortableRequest({ tasks: [] });
+        const secondRequest = makeControlledAbortableRequest({ tasks: [] });
+        const fetchMock = vi.mocked(fetch);
+        const setLoadingTasks = vi.fn();
+        let requestCount = 0;
+        fetchMock.mockImplementation((_input, init) => {
+            const signal = init?.signal;
+            requestCount += 1;
+            if (requestCount === 1) {
+                firstRequest.attach(signal);
+                return firstRequest.promise;
+            }
+            secondRequest.attach(signal);
+            return secondRequest.promise;
+        });
+        const { result } = renderHook(() => useTaskData({
+            tasks: [],
+            archivedTasks: [],
+            setTasks: vi.fn(),
+            setArchivedTasks: vi.fn(),
+            setLoadingTasks,
+            getCurrentWorkspaceId: () => 'workspace-1',
+            workspaceResetKey: 'workspace-1',
+            shouldDeferProtectedApiCalls: false,
+            shouldBlockProtectedApiCalls: false,
+            handleUnauthorized: vi.fn(),
+            authRequiredForApi: false
+        }));
+        let firstPromise;
+        let secondPromise;
+        await act(async () => {
+            firstPromise = result.current.fetchTasks(false);
+            secondPromise = result.current.fetchTasks(true);
+            await Promise.resolve();
+        });
+        expect(setLoadingTasks).toHaveBeenNthCalledWith(1, true);
+        expect(setLoadingTasks).toHaveBeenNthCalledWith(2, false);
+        await act(async () => {
+            secondRequest.resolve();
+            await secondPromise;
+            await firstPromise;
+        });
+        expect(setLoadingTasks).toHaveBeenLastCalledWith(false);
+    });
 });

package/dist/hooks/useTaskMutations.d.ts

@@ -24,8 +24,9 @@ export interface UseTaskMutationsProps {
     pushWorkspaceChangesToCloud: (sig: string) => void;
     workspacePendingSignatureRef: MutableRefObject<string | null>;
     workspaceDeletedTaskIdsRef: MutableRefObject<Set<string>>;
+    workspaceDeletedTaskWatermarksRef: MutableRefObject<Map<string, string>>;
 }
-export declare function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, }: UseTaskMutationsProps): {
+export declare function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, }: UseTaskMutationsProps): {
     copiedId: string | null;
     handleDelete: (id: string, archive?: boolean, options?: {
         skipConfirm?: boolean;