@taskforcehq/taskforce 0.3.303 → 0.3.305

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;

package/dist/hooks/useTaskMutations.js

@@ -1,21 +1,46 @@
-import { useState, useCallback, useRef } from 'react';
+import { useState, useCallback, useEffect, useRef } from 'react';
 import { normalizeTaskFromApi } from '../utils/taskNormalization.js';
-export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, }) {
+export 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, }) {
     // Copy ID state + timer ref
     const [copiedId, setCopiedId] = useState(null);
     const copiedIdTimerRef = useRef(null);
+    const workspaceSyncTimerRef = useRef(null);
+    const workspaceSyncTargetAtRef = useRef(null);
+    useEffect(() => () => {
+        if (typeof window === 'undefined')
+            return;
+        if (workspaceSyncTimerRef.current !== null) {
+            window.clearTimeout(workspaceSyncTimerRef.current);
+            workspaceSyncTimerRef.current = null;
+        }
+        workspaceSyncTargetAtRef.current = null;
+    }, []);
     const queueWorkspaceSyncFromAuthoritativeTaskState = useCallback((delayMs = 0) => {
         if (!(cloudAuthConfigured && runtimeMode === 'local' && isAuthenticated && workspaceCloudSyncEnabled))
             return;
         if (typeof window === 'undefined')
             return;
-        window.setTimeout(() => {
+        const normalizedDelayMs = Math.max(0, delayMs);
+        const requestedTargetAt = Date.now() + normalizedDelayMs;
+        const existingTargetAt = workspaceSyncTargetAtRef.current;
+        if (workspaceSyncTimerRef.current !== null) {
+            if (normalizedDelayMs <= 0)
+                return;
+            if (existingTargetAt !== null && existingTargetAt >= requestedTargetAt)
+                return;
+            window.clearTimeout(workspaceSyncTimerRef.current);
+            workspaceSyncTimerRef.current = null;
+        }
+        workspaceSyncTargetAtRef.current = requestedTargetAt;
+        workspaceSyncTimerRef.current = window.setTimeout(() => {
+            workspaceSyncTimerRef.current = null;
+            workspaceSyncTargetAtRef.current = null;
             const signature = buildWorkspaceSyncSignature();
             if (!signature)
                 return;
             workspacePendingSignatureRef.current = signature;
             void pushWorkspaceChangesToCloud(signature);
-        }, Math.max(0, delayMs));
+        }, normalizedDelayMs);
     }, [
         cloudAuthConfigured,
         runtimeMode,
@@ -65,9 +90,14 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             }
             if (deletedRecord) {
                 setDeletedTasks(prev => [deletedRecord, ...prev.filter((entry) => entry.taskId !== id)]);
+                const deletedAt = String(deletedRecord.deletedAt || '').trim();
+                if (Number.isFinite(Date.parse(deletedAt))) {
+                    workspaceDeletedTaskWatermarksRef.current.set(id, deletedAt);
+                }
             }
             else {
                 await fetchDeletedTasks(true);
+                workspaceDeletedTaskWatermarksRef.current.set(id, new Date().toISOString());
             }
             workspaceDeletedTaskIdsRef.current.add(id);
             if (cloudAuthConfigured && runtimeMode === 'local' && isAuthenticated && workspaceCloudSyncEnabled) {
@@ -108,7 +138,13 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                 await fetchTasks(true);
             }
             setDeletedTasks((prev) => prev.filter((entry) => entry.id !== id && entry.taskId !== id));
+            const restoredTaskId = String(restoredTask?.id || '').trim();
             workspaceDeletedTaskIdsRef.current.delete(id);
+            workspaceDeletedTaskWatermarksRef.current.delete(id);
+            if (restoredTaskId) {
+                workspaceDeletedTaskIdsRef.current.delete(restoredTaskId);
+                workspaceDeletedTaskWatermarksRef.current.delete(restoredTaskId);
+            }
             queueWorkspaceSyncFromAuthoritativeTaskState();
             setError('');
             pushNotice('Task restored from Trash.', 'info');
@@ -227,8 +263,20 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
     }, [tasks, archivedTasks, pushNotice, mergeTaskFromServer, queueWorkspaceSyncFromAuthoritativeTaskState]);
     const handleToggleComplete = async (task) => {
         const newStatus = task.status === 'done' ? 'task' : 'done';
+        const completedAt = newStatus === 'done' ? new Date().toISOString() : undefined;
+        const optimisticUpdates = {
+            status: newStatus,
+            completedAt,
+            completed: newStatus === 'done',
+            inProgress: false,
+            readyForReview: false,
+            cancelled: false
+        };
+        const previousTasks = tasks;
+        const previousArchivedTasks = archivedTasks;
+        setTasks(prev => prev.map(t => t.id === task.id ? { ...t, ...optimisticUpdates } : t));
+        setArchivedTasks(prev => prev.map(t => t.id === task.id ? { ...t, ...optimisticUpdates } : t));
         try {
-            const completedAt = newStatus === 'done' ? new Date().toISOString() : undefined;
             const res = await fetch(`/api/taskforce/task/${task.id}`, {
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
@@ -239,7 +287,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                 const message = data.error || 'Failed to update task status.';
                 setError(message);
                 pushNotice(message, 'error');
-                await fetchTasks(true);
+                setTasks(previousTasks);
+                setArchivedTasks(previousArchivedTasks);
                 return;
             }
             const updatedTask = await res.json().catch(() => null);
@@ -257,7 +306,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             console.error("Failed to toggle complete", err);
             setError('Failed to update task status.');
             pushNotice('Failed to update task status.', 'error');
-            fetchTasks();
+            setTasks(previousTasks);
+            setArchivedTasks(previousArchivedTasks);
         }
     };
     const handleToggleCancel = async (task) => {

package/dist/hooks/useTaskMutations.test.js

@@ -6,9 +6,87 @@ describe('useTaskMutations', () => {
         vi.stubGlobal('fetch', vi.fn());
     });
     afterEach(() => {
+        vi.useRealTimers();
         vi.unstubAllGlobals();
         vi.clearAllMocks();
     });
+    const baseTask = {
+        id: 'task-1',
+        title: 'Test task',
+        description: '',
+        category: 'general',
+        type: 'task',
+        priority: 2,
+        complexity: 3,
+        status: 'task',
+        createdAt: '2026-04-03T10:00:00.000Z',
+        updatedAt: '2026-04-03T10:05:00.000Z'
+    };
+    const buildHook = (overrides = {}) => {
+        const setTasks = vi.fn();
+        const setArchivedTasks = vi.fn();
+        const setDeletedTasks = vi.fn();
+        const setError = vi.fn();
+        const resetForm = vi.fn();
+        const setActiveTab = vi.fn();
+        const fetchTasks = vi.fn();
+        const fetchArchive = vi.fn();
+        const fetchDeletedTasks = vi.fn();
+        const mergeTaskFromServer = vi.fn();
+        const pushNotice = vi.fn();
+        const buildWorkspaceSyncSignature = vi.fn(() => 'sig-1');
+        const pushWorkspaceChangesToCloud = vi.fn();
+        const workspacePendingSignatureRef = { current: null };
+        const workspaceDeletedTaskIdsRef = { current: new Set() };
+        const workspaceDeletedTaskWatermarksRef = { current: new Map() };
+        const hook = renderHook(() => useTaskMutations({
+            tasks: [baseTask],
+            archivedTasks: [],
+            editingTaskId: null,
+            setTasks,
+            setArchivedTasks,
+            setDeletedTasks,
+            setError,
+            resetForm,
+            setActiveTab,
+            fetchTasks,
+            fetchArchive,
+            fetchDeletedTasks,
+            mergeTaskFromServer,
+            pushNotice,
+            cloudAuthConfigured: true,
+            runtimeMode: 'local',
+            isAuthenticated: true,
+            workspaceCloudSyncEnabled: true,
+            buildWorkspaceSyncSignature,
+            pushWorkspaceChangesToCloud,
+            workspacePendingSignatureRef,
+            workspaceDeletedTaskIdsRef,
+            workspaceDeletedTaskWatermarksRef,
+            ...overrides
+        }));
+        return {
+            ...hook,
+            deps: {
+                setTasks,
+                setArchivedTasks,
+                setDeletedTasks,
+                setError,
+                resetForm,
+                setActiveTab,
+                fetchTasks,
+                fetchArchive,
+                fetchDeletedTasks,
+                mergeTaskFromServer,
+                pushNotice,
+                buildWorkspaceSyncSignature,
+                pushWorkspaceChangesToCloud,
+                workspacePendingSignatureRef,
+                workspaceDeletedTaskIdsRef,
+                workspaceDeletedTaskWatermarksRef
+            }
+        };
+    };
     it('clears pending delete ids when a deleted task is restored', async () => {
         const fetchMock = vi.mocked(fetch);
         fetchMock.mockResolvedValue({
@@ -42,6 +120,7 @@ describe('useTaskMutations', () => {
         const pushWorkspaceChangesToCloud = vi.fn();
         const workspacePendingSignatureRef = { current: null };
         const workspaceDeletedTaskIdsRef = { current: new Set(['task-1']) };
+        const workspaceDeletedTaskWatermarksRef = { current: new Map([['task-1', '2026-04-03T10:10:00.000Z']]) };
         const { result } = renderHook(() => useTaskMutations({
             tasks: [],
             archivedTasks: [],
@@ -65,6 +144,7 @@ describe('useTaskMutations', () => {
             pushWorkspaceChangesToCloud,
             workspacePendingSignatureRef,
             workspaceDeletedTaskIdsRef,
+            workspaceDeletedTaskWatermarksRef,
         }));
         await act(async () => {
             await result.current.handleRestoreDeletedTask('task-1');
@@ -72,9 +152,105 @@ describe('useTaskMutations', () => {
         await waitFor(() => {
             expect(workspaceDeletedTaskIdsRef.current.has('task-1')).toBe(false);
         });
+        expect(workspaceDeletedTaskWatermarksRef.current.has('task-1')).toBe(false);
         expect(mergeTaskFromServer).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1' }));
         expect(buildWorkspaceSyncSignature).toHaveBeenCalled();
         expect(pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
         expect(setDeletedTasks).toHaveBeenCalled();
     });
+    it('records the delete watermark immediately when a task delete succeeds', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: async () => ({
+                deleted: {
+                    id: 'deleted-task-1',
+                    taskId: 'task-1',
+                    deletedAt: '2026-04-03T10:10:00.000Z',
+                    taskSnapshot: baseTask
+                }
+            })
+        });
+        const { result, deps } = buildHook();
+        await act(async () => {
+            await result.current.handleDelete('task-1', false, { skipConfirm: true });
+        });
+        expect(deps.workspaceDeletedTaskIdsRef.current.has('task-1')).toBe(true);
+        expect(deps.workspaceDeletedTaskWatermarksRef.current.get('task-1')).toBe('2026-04-03T10:10:00.000Z');
+        expect(deps.buildWorkspaceSyncSignature).toHaveBeenCalled();
+        expect(deps.pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
+    });
+    it('optimistically marks a task done before the server responds', async () => {
+        let resolveResponse;
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockImplementation(() => new Promise((resolve) => {
+            resolveResponse = resolve;
+        }));
+        const { result, deps } = buildHook();
+        let togglePromise = null;
+        await act(async () => {
+            togglePromise = result.current.handleToggleComplete(baseTask);
+        });
+        expect(deps.setTasks).toHaveBeenCalledTimes(1);
+        const optimisticUpdater = deps.setTasks.mock.calls[0]?.[0];
+        const optimisticTasks = optimisticUpdater([baseTask]);
+        expect(optimisticTasks[0]?.status).toBe('done');
+        expect(optimisticTasks[0]?.completed).toBe(true);
+        resolveResponse({
+            ok: true,
+            status: 200,
+            json: async () => ({ ...baseTask, status: 'done', completedAt: '2026-04-14T12:00:00.000Z' })
+        });
+        await act(async () => {
+            await togglePromise;
+        });
+        expect(deps.mergeTaskFromServer).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: 'done' }));
+    });
+    it('rolls back the optimistic done state when the server update fails', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: false,
+            status: 500,
+            json: async () => ({ error: 'Server exploded' })
+        });
+        const { result, deps } = buildHook();
+        await act(async () => {
+            await result.current.handleToggleComplete(baseTask);
+        });
+        expect(deps.setTasks).toHaveBeenCalledTimes(2);
+        expect(deps.setTasks.mock.calls[1]?.[0]).toEqual([baseTask]);
+        expect(deps.setArchivedTasks.mock.calls[1]?.[0]).toEqual([]);
+        expect(deps.pushNotice).toHaveBeenCalledWith('Server exploded', 'error');
+        expect(deps.mergeTaskFromServer).not.toHaveBeenCalled();
+    });
+    it('coalesces pending workspace sync pushes and preserves attachment delay', async () => {
+        vi.useFakeTimers();
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: async () => ({ ...baseTask, updatedAt: '2026-04-14T12:00:00.000Z' })
+        });
+        const { result, deps } = buildHook();
+        await act(async () => {
+            await result.current.handleUpdateTask(baseTask.id, { description: 'First update' });
+        });
+        await act(async () => {
+            await result.current.handleUpdateTask(baseTask.id, {
+                attachments: [{ id: 'asset-1', path: 'workspaces/workspace-local-active/assets/file.txt' }]
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(149);
+        });
+        expect(deps.pushWorkspaceChangesToCloud).not.toHaveBeenCalled();
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(1);
+        });
+        expect(deps.buildWorkspaceSyncSignature).toHaveBeenCalledTimes(1);
+        expect(deps.workspacePendingSignatureRef.current).toBe('sig-1');
+        expect(deps.pushWorkspaceChangesToCloud).toHaveBeenCalledTimes(1);
+        expect(deps.pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
+    });
 });

package/dist/hooks/useTaskforce.d.ts

@@ -122,7 +122,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     authUserDisplayName: string;
     authUserAvatarUrl: string;
     authWorkspaceId: string;
-    userGlobalSyncStatus: "error" | "idle" | "syncing" | "disconnected";
+    userGlobalSyncStatus: "error" | "idle" | "disconnected" | "syncing";
     workspaceLastPullAt: string | null;
     workspaceLastPushAt: string | null;
     workspaceLastErrorAt: string | null;
@@ -130,6 +130,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     workspaceLastErrorMessage: string | null;
     workspaceLastSuccessfulSyncAt: string | null;
     workspaceSyncPhase: import("../sync/workspaceSyncState").WorkspaceSyncPhase;
+    workspaceSyncSetupIntent: import("../sync/workspaceSyncState").WorkspaceSyncSetupIntent;
     workspaceSyncStatus: import("./useSyncOrchestrator").WorkspaceSyncStatus;
     workspaceSyncSummary: string;
     workspaceSyncRecommendedAction: string;
@@ -180,10 +181,10 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         success: boolean;
         error?: string;
     }>;
-    applyWorkspaceSyncStateSnapshot: (nextState: Partial<import("../sync/workspaceSyncState").WorkspaceSyncStateV2> & {
+    applyWorkspaceSyncStateSnapshot: (nextState: Parameters<(nextState: Partial<import("../sync/workspaceSyncState").WorkspaceSyncStateV2> & {
         enabled: boolean;
         phase?: import("../sync/workspaceSyncState").WorkspaceSyncPhase | null;
-    }) => void;
+    }) => void>[0]) => void;
     authSessionResolved: boolean;
     workspaceBootstrapPending: boolean;
     bootstrapPhase: BootstrapPhase;
@@ -193,6 +194,12 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     runtimeCapabilities: RuntimeCapabilities | null;
     refreshSetupContext: () => Promise<void>;
     retryBootstrapChecks: () => Promise<void>;
+    continueAfterCommercialOnboarding: () => Promise<{
+        success: boolean;
+        destination: "app" | "setup" | "login";
+        error?: string;
+        code?: string;
+    }>;
     saveWorkspaceProfile: (input: {
         name: string;
         description?: string;
@@ -206,7 +213,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     fetchWorkspaces: () => Promise<{
         success: boolean;
         error?: string;
-        workspaces?: WorkspaceSummary[];
+        workspaces?: import("./workspace/useTaskforceWorkspaceBootstrap").WorkspaceSummary[];
     }>;
     createWorkspace: (name: string, description?: string) => Promise<{
         success: boolean;
@@ -274,6 +281,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         code?: string;
         verificationToken?: string | null;
         emailSent?: boolean;
+        deliveryAttempted?: boolean;
         emailError?: string;
     }>;
     confirmEmailVerification: (token: string) => Promise<{
@@ -287,6 +295,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         code?: string;
         resetToken?: string | null;
         emailSent?: boolean;
+        deliveryAttempted?: boolean;
         emailError?: string;
     }>;
     confirmPasswordReset: (token: string, password: string) => Promise<{