@taskforcehq/taskforce 0.3.304 → 0.3.305

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();
     });
@@ -1418,6 +1424,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')) {

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,6 +1,6 @@
 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);
@@ -90,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) {
@@ -133,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');

package/dist/hooks/useTaskMutations.test.js

@@ -38,6 +38,7 @@ describe('useTaskMutations', () => {
         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: [],
@@ -61,6 +62,7 @@ describe('useTaskMutations', () => {
             pushWorkspaceChangesToCloud,
             workspacePendingSignatureRef,
             workspaceDeletedTaskIdsRef,
+            workspaceDeletedTaskWatermarksRef,
             ...overrides
         }));
         return {
@@ -80,7 +82,8 @@ describe('useTaskMutations', () => {
                 buildWorkspaceSyncSignature,
                 pushWorkspaceChangesToCloud,
                 workspacePendingSignatureRef,
-                workspaceDeletedTaskIdsRef
+                workspaceDeletedTaskIdsRef,
+                workspaceDeletedTaskWatermarksRef
             }
         };
     };
@@ -117,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: [],
@@ -140,6 +144,7 @@ describe('useTaskMutations', () => {
             pushWorkspaceChangesToCloud,
             workspacePendingSignatureRef,
             workspaceDeletedTaskIdsRef,
+            workspaceDeletedTaskWatermarksRef,
         }));
         await act(async () => {
             await result.current.handleRestoreDeletedTask('task-1');
@@ -147,11 +152,35 @@ 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);

package/dist/hooks/useTaskforce.d.ts

@@ -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;
@@ -280,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<{
@@ -293,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<{

package/dist/hooks/useTaskforce.js

@@ -235,8 +235,13 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             || path.startsWith('/api/taskforce/billing/')
             || path.startsWith('/api/taskforce/sync/')
             || path.startsWith('/api/taskforce/settings/mcp/');
-        if (!isCloudHost && isCloudScopedPath && (!runtimeConfigReady || runtimeConfigOverride.cloudAuthViaLocalProxy)) {
-            return path;
+        if (!isCloudHost && isCloudScopedPath) {
+            if (!runtimeConfigReady || runtimeConfigOverride.cloudAuthViaLocalProxy) {
+                return path;
+            }
+            if (runtimeConfigOverride.workspaceMode === 'multi-cloud') {
+                return path;
+            }
         }
         const base = normalizedCloudAuthBaseUrl || normalizedApiBaseUrl;
         if (base) {
@@ -258,7 +263,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (!isCloudHost && isCloudScopedPath)
             return path;
         return path;
-    }, [runtimeConfigReady, runtimeConfigOverride.cloudAuthViaLocalProxy, normalizedCloudAuthBaseUrl, normalizedApiBaseUrl, isCloudHost]);
+    }, [runtimeConfigReady, runtimeConfigOverride.cloudAuthViaLocalProxy, runtimeConfigOverride.workspaceMode, normalizedCloudAuthBaseUrl, normalizedApiBaseUrl, isCloudHost]);
     const resolveWebSocketUrl = useCallback((path) => {
         const wsPath = String(path || '').trim() || '/taskforce-ws';
         const normalizedPath = wsPath.startsWith('/') ? wsPath : `/${wsPath}`;
@@ -815,7 +820,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const setUserGlobalSyncErrorRef = useRef(() => undefined);
     const checkAuthSessionImplRef = useRef(async () => false);
     const checkAuthSession = useCallback((options) => checkAuthSessionImplRef.current(options), []);
-    const { userGlobalSyncStatus, setUserGlobalSyncStatus, userGlobalSyncError, setUserGlobalSyncError, workspaceLastPullAt, workspaceLastPushAt, workspaceLastErrorAt, workspaceLastErrorMessage, workspaceLastSuccessfulSyncAt, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceSyncStatus, workspaceSyncSummary, workspaceSyncRecommendedAction, workspaceSyncBusy, workspaceSyncPendingChanges, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspacePullCursorRef, clearWorkspaceRetry, persistWorkspaceSyncPatch, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot, syncUserGlobalSettings, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, saveWorkspaceCloudSyncSettings, retryUserGlobalSettingsSync, retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull, getWorkspaceSyncDiagnostics } = useSyncOrchestrator({
+    const { userGlobalSyncStatus, setUserGlobalSyncStatus, userGlobalSyncError, setUserGlobalSyncError, workspaceLastPullAt, workspaceLastPushAt, workspaceLastErrorAt, workspaceLastErrorMessage, workspaceLastSuccessfulSyncAt, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceSyncSetupIntent, workspaceSyncStatus, workspaceSyncSummary, workspaceSyncRecommendedAction, workspaceSyncBusy, workspaceSyncPendingChanges, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, clearWorkspaceRetry, persistWorkspaceSyncPatch, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot, syncUserGlobalSettings, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, saveWorkspaceCloudSyncSettings, retryUserGlobalSettingsSync, retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull, getWorkspaceSyncDiagnostics } = useSyncOrchestrator({
         currentWorkspaceId,
         cloudAuthConfigured,
         runtimeMode,
@@ -828,6 +833,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         realtimeSyncEnabled,
         tasks,
         archivedTasks,
+        deletedTasks,
         initiatives,
         workstreams,
         taxonomies,
@@ -1800,6 +1806,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 success: true,
                 verificationToken: data?.verificationToken ?? null,
                 emailSent: data?.emailSent !== false,
+                deliveryAttempted: data?.deliveryAttempted === true
+                    || (typeof data?.verificationToken === 'string' && data.verificationToken.trim().length > 0),
                 emailError: typeof data?.emailError === 'string' ? data.emailError : undefined
             };
         }
@@ -1853,6 +1861,8 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 success: true,
                 resetToken: data?.resetToken ?? null,
                 emailSent: data?.emailSent !== false,
+                deliveryAttempted: data?.deliveryAttempted === true
+                    || (typeof data?.resetToken === 'string' && data.resetToken.trim().length > 0),
                 emailError: typeof data?.emailError === 'string' ? data.emailError : undefined
             };
         }
@@ -1987,7 +1997,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
                 return { success: false, error: data?.error || 'Invite join failed.', code: data?.code };
             }
             setError('');
-            await checkAuthSession();
+            await checkAuthSession({ force: true });
             const preferredWorkspaceId = typeof data?.workspaceId === 'string' ? data.workspaceId : null;
             const workspaceResolution = await resolveWorkspaceAfterAuth({ preferredWorkspaceId });
             if (!workspaceResolution.success) {
@@ -2723,6 +2733,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         pushWorkspaceChangesToCloud,
         workspacePendingSignatureRef,
         workspaceDeletedTaskIdsRef,
+        workspaceDeletedTaskWatermarksRef,
     });
     const { autoSaveState, flushAutoSave, scheduleWarningPrompt, handleSubmit, confirmScheduleWarning, cancelScheduleWarning, handleAddComment } = useTaskFormActions({
         activeCategories,
@@ -2992,6 +3003,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         workspaceLastErrorMessage,
         workspaceLastSuccessfulSyncAt,
         workspaceSyncPhase,
+        workspaceSyncSetupIntent,
         workspaceSyncStatus,
         workspaceSyncSummary,
         workspaceSyncRecommendedAction,

package/dist/hooks/useTaskforce.sync-behavior.test.js

@@ -1097,6 +1097,84 @@ describe('useTaskforce sync behavior', () => {
             expect(result.current.authSessionResolved).toBe(true);
         });
     });
+    it('keeps loopback cloud runtime auth on same-origin after runtime config resolves', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.startsWith('https://app.taskforcehq.ai/api/taskforce/auth/session')) {
+                return jsonResponse({ authenticated: false, authRequiredForApi: true }, 401);
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Loopback Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://app.taskforcehq.ai' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.authSessionResolved).toBe(true);
+            expect(result.current.isAuthenticated).toBe(true);
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+        });
+        expect(fetchMock.mock.calls.some(([url]) => String(url).startsWith('https://app.taskforcehq.ai/api/taskforce/auth/session'))).toBe(false);
+    });
     it('enables cloud realtime refresh for authenticated sessions and refreshes open task comments from signals', async () => {
         vi.stubGlobal('WebSocket', MockWebSocket);
         let invalidationTaskFetchCount = 0;

package/dist/hooks/useWorkspaceSyncController.d.ts

@@ -1,5 +1,5 @@
 import type { EnsureWorkspaceReadyResult } from '../sync/syncService';
-import { type WorkspaceSyncPhase, type WorkspaceSyncStateV2 } from '../sync/workspaceSyncState';
+import { type WorkspaceSyncSetupIntent, type WorkspaceSyncPhase, type WorkspaceSyncStateV2 } from '../sync/workspaceSyncState';
 type WorkspaceSyncLeaseOperation = 'pull' | 'push' | 'repair';
 interface WorkspaceSyncLeaseRecord {
     ownerId: string;
@@ -12,6 +12,7 @@ interface UseWorkspaceSyncControllerInput {
     currentWorkspaceId: string;
     setWorkspaceCloudSyncEnabled: (value: boolean) => void;
     setWorkspaceSyncPhase: (value: WorkspaceSyncPhase) => void;
+    setWorkspaceSyncSetupIntent: (value: WorkspaceSyncSetupIntent) => void;
     setWorkspaceLastPullAt: (value: string | null) => void;
     setWorkspaceLastPushAt: (value: string | null) => void;
     setWorkspaceLastErrorMessage: (value: string | null) => void;
@@ -30,6 +31,7 @@ export declare function useWorkspaceSyncController(input: UseWorkspaceSyncContro
     workspacePendingSignatureRef: import("react").RefObject<string>;
     workspaceLastPushedTaskIdsRef: import("react").RefObject<Set<string>>;
     workspaceDeletedTaskIdsRef: import("react").RefObject<Set<string>>;
+    workspaceDeletedTaskWatermarksRef: import("react").RefObject<Map<string, string>>;
     workspacePullCursorRef: import("react").RefObject<string | null>;
     clearWorkspaceRetry: () => void;
     scheduleWorkspaceRetry: (invokeSync: () => Promise<boolean>, options?: {

package/dist/hooks/useWorkspaceSyncController.js

@@ -59,6 +59,7 @@ function buildWorkspaceSyncStatePatch(current, patch) {
         ...patch,
         version: 2,
         phase: patch.phase || current.phase,
+        setupIntent: patch.setupIntent === undefined ? (current.setupIntent ?? null) : (patch.setupIntent ?? null),
         pullCursor: patch.pullCursor === undefined ? current.pullCursor : normalizeCursor(patch.pullCursor),
         lastPullAt: patch.lastPullAt === undefined ? current.lastPullAt : normalizeCursor(patch.lastPullAt),
         lastPushAt: patch.lastPushAt === undefined ? current.lastPushAt : normalizeCursor(patch.lastPushAt),
@@ -67,12 +68,13 @@ function buildWorkspaceSyncStatePatch(current, patch) {
     };
     if (!next.enabled) {
         next.phase = 'idle';
+        next.setupIntent = null;
         next.pullCursor = null;
     }
     return next;
 }
 export function useWorkspaceSyncController(input) {
-    const { currentWorkspaceId, setWorkspaceCloudSyncEnabled, setWorkspaceSyncPhase, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceLastErrorMessage } = input;
+    const { currentWorkspaceId, setWorkspaceCloudSyncEnabled, setWorkspaceSyncPhase, setWorkspaceSyncSetupIntent, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceLastErrorMessage } = input;
     const [workspaceRetryAt, setWorkspaceRetryAt] = useState(null);
     const workspaceRetryTimerRef = useRef(null);
     const workspaceRetryAtMsRef = useRef(null);
@@ -86,6 +88,7 @@ export function useWorkspaceSyncController(input) {
     const workspacePendingSignatureRef = useRef('');
     const workspaceLastPushedTaskIdsRef = useRef(new Set());
     const workspaceDeletedTaskIdsRef = useRef(new Set());
+    const workspaceDeletedTaskWatermarksRef = useRef(new Map());
     const workspacePullCursorRef = useRef(null);
     const workspaceSyncStateRef = useRef(createDefaultWorkspaceSyncState());
     const workspaceSyncLeaseOwnerIdRef = useRef('');
@@ -255,6 +258,7 @@ export function useWorkspaceSyncController(input) {
         const next = buildWorkspaceSyncStatePatch(current, {
             enabled: Boolean(nextState.enabled),
             phase: nextState.phase || current.phase,
+            setupIntent: nextState.setupIntent,
             pullCursor: nextState.pullCursor,
             lastPullAt: nextState.lastPullAt,
             lastPushAt: nextState.lastPushAt,
@@ -265,12 +269,14 @@ export function useWorkspaceSyncController(input) {
         workspacePullCursorRef.current = next.pullCursor;
         setWorkspaceCloudSyncEnabled(next.enabled);
         setWorkspaceSyncPhase(next.phase);
+        setWorkspaceSyncSetupIntent(next.setupIntent ?? null);
         setWorkspaceLastPullAt(next.lastPullAt);
         setWorkspaceLastPushAt(next.lastPushAt);
         setWorkspaceLastErrorMessage(next.lastErrorMessage ?? null);
     }, [
         setWorkspaceCloudSyncEnabled,
         setWorkspaceSyncPhase,
+        setWorkspaceSyncSetupIntent,
         setWorkspaceLastPullAt,
         setWorkspaceLastPushAt,
         setWorkspaceLastErrorMessage
@@ -343,6 +349,7 @@ export function useWorkspaceSyncController(input) {
                 await persistWorkspaceSyncPatch({
                     enabled: false,
                     phase: 'idle',
+                    setupIntent: null,
                     pullCursor: null
                 });
                 return { success: true };
@@ -360,6 +367,7 @@ export function useWorkspaceSyncController(input) {
             await persistWorkspaceSyncPatch({
                 enabled: true,
                 phase: ensured.provisioned ? 'provision-local' : 'attach-cloud',
+                setupIntent: null,
                 pullCursor: null,
                 lastPullAt: null,
                 lastPushAt: null,
@@ -376,6 +384,7 @@ export function useWorkspaceSyncController(input) {
         workspacePendingSignatureRef.current = '';
         workspaceLastPushedTaskIdsRef.current = new Set();
         workspaceDeletedTaskIdsRef.current = new Set();
+        workspaceDeletedTaskWatermarksRef.current = new Map();
         workspacePullCursorRef.current = null;
         workspaceSyncStateRef.current = createDefaultWorkspaceSyncState();
         workspacePushInFlightRef.current = false;
@@ -413,6 +422,7 @@ export function useWorkspaceSyncController(input) {
         workspacePendingSignatureRef,
         workspaceLastPushedTaskIdsRef,
         workspaceDeletedTaskIdsRef,
+        workspaceDeletedTaskWatermarksRef,
         workspacePullCursorRef,
         clearWorkspaceRetry,
         scheduleWorkspaceRetry,

package/dist/hooks/useWorkspaceSyncController.test.js

@@ -5,6 +5,7 @@ const makeInput = (overrides = {}) => ({
     currentWorkspaceId: 'ws-test',
     setWorkspaceCloudSyncEnabled: vi.fn(),
     setWorkspaceSyncPhase: vi.fn(),
+    setWorkspaceSyncSetupIntent: vi.fn(),
     setWorkspaceLastPullAt: vi.fn(),
     setWorkspaceLastPushAt: vi.fn(),
     setWorkspaceLastErrorMessage: vi.fn(),

package/dist/mcp/adminWorkspaceRegistrar.d.ts

@@ -0,0 +1,2 @@
+import type { DomainToolExecutor, RegisterMcpTool } from './toolCatalog.js';
+export declare function registerAdminWorkspaceTools(registerTool: RegisterMcpTool, executeTool: DomainToolExecutor): void;