@taskforcehq/taskforce 0.3.302 → 0.3.304

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

@@ -3,19 +3,44 @@ import { act, renderHook, waitFor } from '@testing-library/react';
 import { useSyncOrchestrator } from './useSyncOrchestrator';
 class MockWebSocket {
     static instances = [];
+    static OPEN = 1;
+    static CLOSED = 3;
     url;
+    readyState = 0;
+    sent = [];
+    listeners = new Map();
     constructor(url) {
         this.url = url;
         MockWebSocket.instances.push(this);
     }
     close() {
-        // noop for orchestration gating tests
+        this.readyState = MockWebSocket.CLOSED;
+        this.emit('close', {});
     }
-    addEventListener() {
-        // noop for orchestration gating tests
+    addEventListener(type, listener) {
+        const bucket = this.listeners.get(type) || new Set();
+        bucket.add(listener);
+        this.listeners.set(type, bucket);
     }
-    send() {
-        // noop for orchestration gating tests
+    send(payload) {
+        if (typeof payload === 'string') {
+            this.sent.push(payload);
+        }
+    }
+    emit(type, event) {
+        const bucket = this.listeners.get(type);
+        if (!bucket)
+            return;
+        for (const listener of bucket) {
+            listener(event);
+        }
+    }
+    open() {
+        this.readyState = MockWebSocket.OPEN;
+        this.emit('open', {});
+    }
+    message(payload) {
+        this.emit('message', { data: JSON.stringify(payload) });
     }
 }
 const { ensureCloudWorkspaceReadyForSyncServiceMock, runWorkspacePullSyncServiceMock, runWorkspacePushSyncServiceMock, syncUserGlobalSettingsServiceMock } = vi.hoisted(() => ({
@@ -74,7 +99,52 @@ function buildInput(overrides) {
 describe('useSyncOrchestrator', () => {
     beforeEach(() => {
         localStorage.clear();
+        ensureCloudWorkspaceReadyForSyncServiceMock.mockReset();
+        runWorkspacePullSyncServiceMock.mockReset();
+        runWorkspacePushSyncServiceMock.mockReset();
+        syncUserGlobalSettingsServiceMock.mockReset();
         ensureCloudWorkspaceReadyForSyncServiceMock.mockResolvedValue({ success: true });
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T18:00:00.000Z',
+            cursor: null,
+            pages: 0,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T18:00:00.000Z',
+            requestMs: 1,
+            changeCount: 0,
+            deleteCount: 0,
+            currentTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(),
+            currentAiProfileWatermarks: new Map(),
+            currentDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentDocumentReviewCommentIds: new Set(),
+            currentDocumentReviewCommentWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            currentTaskEventWatermarks: new Map(),
+            deleteTaskIds: new Set(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: []
+        });
         syncUserGlobalSettingsServiceMock.mockResolvedValue({
             success: true,
             mode: 'pulled',
@@ -206,6 +276,293 @@ describe('useSyncOrchestrator', () => {
         expect(MockWebSocket.instances[0]?.url).toBe('wss://api.example.com/taskforce-ws');
         unmount();
     });
+    it('lets a realtime signal break transient retry backoff and pull immediately', async () => {
+        vi.useFakeTimers();
+        vi.stubGlobal('WebSocket', MockWebSocket);
+        runWorkspacePullSyncServiceMock
+            .mockResolvedValueOnce({
+            success: false,
+            kind: 'pull_http',
+            status: 502,
+            transient: true,
+            retryAfterMs: 60_000,
+            cursor: null,
+            pages: 0,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        })
+            .mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-03-15T18:05:00.000Z',
+            cursor: null,
+            pages: 1,
+            appliedChanges: 1,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: true,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({ realtimeSyncEnabled: true })
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await act(async () => {
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(result.current.workspaceRetryAt).not.toBeNull();
+        expect(MockWebSocket.instances).toHaveLength(1);
+        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(1);
+        act(() => {
+            MockWebSocket.instances[0]?.open();
+            MockWebSocket.instances[0]?.message({
+                type: 'taskforce:update',
+                workspaceId: 'workspace-local-active'
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(300);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(2);
+        expect(result.current.workspaceRetryAt).toBeNull();
+        expect(result.current.workspaceLastPullAt).toBe('2026-03-15T18:05:00.000Z');
+        unmount();
+    });
+    it('refreshes local task collections after event-only task activity pulls', async () => {
+        const fetchSpy = 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,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/documents')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/events')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        });
+        vi.stubGlobal('fetch', fetchSpy);
+        runWorkspacePullSyncServiceMock.mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-03-15T18:06:00.000Z',
+            cursor: null,
+            pages: 1,
+            appliedChanges: 1,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            pulledTaskEventUpserts: true,
+            documentDecryptFailures: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput()
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await waitFor(() => {
+            expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(1);
+        });
+        await waitFor(() => {
+            expect(fetchSpy.mock.calls.some(([url]) => String(url).includes('/api/taskforce/tasks'))).toBe(true);
+            expect(fetchSpy.mock.calls.some(([url]) => String(url).includes('/api/taskforce/archive'))).toBe(true);
+        });
+        unmount();
+    });
+    it('marks sync auth as blocked on explicit 401 pull failures', async () => {
+        const setAuthBlocked = vi.fn();
+        const setIsAuthenticated = vi.fn();
+        const checkAuthSession = vi.fn(async () => false);
+        runWorkspacePullSyncServiceMock.mockResolvedValueOnce({
+            success: false,
+            kind: 'pull_http',
+            status: 401,
+            transient: false,
+            retryAfterMs: null,
+            cursor: null,
+            pages: 0,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({
+                setAuthBlocked,
+                setIsAuthenticated,
+                checkAuthSession
+            })
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await waitFor(() => {
+            expect(setAuthBlocked).toHaveBeenCalledWith(true);
+            expect(setIsAuthenticated).toHaveBeenCalledWith(false);
+            expect(checkAuthSession).toHaveBeenCalled();
+            expect(result.current.workspaceLastErrorMessage).toBe('Session expired. Sign in again to resume cloud sync.');
+        });
+        unmount();
+    });
+    it('suppresses self-emitted realtime event ids but still pulls on later replay signals', async () => {
+        vi.useFakeTimers();
+        vi.stubGlobal('WebSocket', MockWebSocket);
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T15:00:00.000Z',
+            requestMs: 1,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(['task-1']),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(),
+            currentAiProfileWatermarks: new Map(),
+            currentDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentDocumentReviewCommentIds: new Set(),
+            currentDocumentReviewCommentWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            currentTaskEventWatermarks: new Map(),
+            deleteTaskIds: new Set(),
+            pushedWatermarks: new Map([['task-1', '2026-03-14T12:00:00.000Z']]),
+            emittedEventIds: ['evt-self-1']
+        });
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T18:05:00.000Z',
+            cursor: null,
+            pages: 1,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        const task = {
+            id: 'task-1',
+            status: 'task',
+            title: 'Realtime suppression',
+            createdAt: '2026-03-14T12:00:00.000Z',
+            updatedAt: '2026-03-14T12:00:00.000Z'
+        };
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({
+                realtimeSyncEnabled: true,
+                tasks: [task]
+            })
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await act(async () => {
+            await Promise.resolve();
+            await Promise.resolve();
+            await vi.advanceTimersByTimeAsync(400);
+        });
+        expect(MockWebSocket.instances).toHaveLength(1);
+        const stabilizedPullCalls = runWorkspacePullSyncServiceMock.mock.calls.length;
+        await act(async () => {
+            await result.current.pushWorkspaceChangesToCloud('sig-self-event');
+            await vi.advanceTimersByTimeAsync(200);
+        });
+        const pullCallsAfterPush = runWorkspacePullSyncServiceMock.mock.calls.length;
+        expect(pullCallsAfterPush).toBeGreaterThanOrEqual(stabilizedPullCalls);
+        act(() => {
+            MockWebSocket.instances[0]?.open();
+            MockWebSocket.instances[0]?.message({
+                type: 'taskforce:update',
+                workspaceId: 'workspace-local-active',
+                eventId: 'evt-self-1'
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(300);
+        });
+        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(pullCallsAfterPush);
+        act(() => {
+            MockWebSocket.instances[0]?.message({
+                type: 'taskforce:update',
+                workspaceId: 'workspace-local-active',
+                eventId: 'evt-replay-2'
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(300);
+        });
+        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(pullCallsAfterPush + 1);
+        await act(async () => {
+            unmount();
+            await vi.runOnlyPendingTimersAsync();
+        });
+    });
     it('retries transient push failures automatically', async () => {
         runWorkspacePushSyncServiceMock
             .mockResolvedValueOnce({
@@ -299,7 +656,20 @@ describe('useSyncOrchestrator', () => {
         })
             .mockImplementationOnce(() => new Promise((resolve) => {
             resolveRetryPull = resolve;
-        }));
+        }))
+            .mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T19:30: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()
         });
@@ -343,6 +713,218 @@ describe('useSyncOrchestrator', () => {
         });
         unmount();
     });
+    it('schedules a push when local task state changes without waiting for snapshot fingerprint changes', async () => {
+        vi.useFakeTimers();
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T19:30:00.000Z',
+            cursor: null,
+            pages: 1,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T15:00:00.000Z',
+            requestMs: 1,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(['task-local-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-1', '2026-03-14T12:00:00.000Z']]),
+            emittedEventIds: []
+        });
+        let input = buildInput();
+        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();
+        input = buildInput({
+            tasks: [{
+                    id: 'task-local-1',
+                    title: 'Local pending task',
+                    status: 'task',
+                    createdAt: '2026-03-14T12:00:00.000Z',
+                    updatedAt: '2026-03-14T12:00:00.000Z',
+                    localReferenceNumber: 7,
+                    referenceNumber: null
+                }]
+        });
+        rerender(input);
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(1600);
+            await Promise.resolve();
+            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'
+                })
+            })
+        ]));
+        unmount();
+    });
+    it('schedules a push when only task activity events change', async () => {
+        vi.useFakeTimers();
+        const baseTask = {
+            id: 'task-local-activity-1',
+            title: 'Local task activity',
+            status: 'task',
+            createdAt: '2026-03-14T12:00:00.000Z',
+            updatedAt: '2026-03-14T12:00:00.000Z',
+            taskEvents: []
+        };
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T15:05:00.000Z',
+            requestMs: 1,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(['task-local-activity-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(),
+            currentTaskEventWatermarks: new Map(),
+            pushedWatermarks: new Map([['task-local-activity-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();
+        input = buildInput({
+            tasks: [{
+                    ...baseTask,
+                    taskEvents: [{
+                            id: 'event-1',
+                            taskId: 'task-local-activity-1',
+                            workspaceId: 'workspace-local-active',
+                            action: 'updated',
+                            actor: 'user-1',
+                            actorType: 'human',
+                            createdAt: '2026-03-15T15:06:00.000Z',
+                            details: {
+                                changes: {
+                                    status: {
+                                        from: 'task',
+                                        to: 'task'
+                                    }
+                                }
+                            }
+                        }]
+                }]
+        });
+        rerender(input);
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(1600);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+        expect(runWorkspacePushSyncServiceMock.mock.calls[0]?.[0]?.payload?.changes).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                op: 'task-event-upsert',
+                event: expect.objectContaining({
+                    id: 'event-1',
+                    taskId: 'task-local-activity-1'
+                })
+            })
+        ]));
+        unmount();
+    });
+    it('runs a startup full reconcile after the first successful pull when a saved cursor exists', async () => {
+        vi.useFakeTimers();
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T19:30:00.000Z',
+            cursor: 'server-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(300);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(2);
+        expect(runWorkspacePullSyncServiceMock.mock.calls.some((call) => call?.[0]?.cursor === 'stale-cursor')).toBe(true);
+        expect(runWorkspacePullSyncServiceMock.mock.calls.some((call) => call?.[0]?.cursor === null)).toBe(true);
+        unmount();
+    });
     it('finishes provision-local bootstrap by moving to active after the first push', async () => {
         runWorkspacePushSyncServiceMock.mockResolvedValue({
             success: true,
@@ -414,6 +996,80 @@ describe('useSyncOrchestrator', () => {
         });
         unmount();
     });
+    it('finishes attach-cloud bootstrap locally even if persisting the active phase fails', 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: 'attach-cloud',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                return Promise.resolve({
+                    ok: false,
+                    status: 502,
+                    json: () => Promise.resolve({ success: false, error: 'Bad gateway' })
+                });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/documents')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/events')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        }));
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T19:05: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()
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'attach-cloud',
+                pullCursor: null
+            });
+        });
+        await waitFor(() => {
+            expect(result.current.workspaceSyncPhase).toBe('active');
+            expect(result.current.workspaceLastPullAt).toBe('2026-03-15T19:05:00.000Z');
+        });
+        expect(result.current.workspaceLastErrorMessage).toBeNull();
+        expect(result.current.workspaceSyncStatus).toBe('healthy');
+        unmount();
+    });
     it('does not auto-push local state immediately after attach-cloud bootstrap completes', async () => {
         vi.useFakeTimers();
         const task = {
@@ -730,7 +1386,8 @@ describe('useSyncOrchestrator', () => {
             await Promise.resolve();
             await Promise.resolve();
         });
-        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(1);
+        const pullCallsDuringRepair = runWorkspacePullSyncServiceMock.mock.calls.length;
+        expect(pullCallsDuringRepair).toBeGreaterThanOrEqual(1);
         await act(async () => {
             const pushed = await result.current.pushWorkspaceChangesToCloud('sig-during-repair');
             const pulled = await result.current.pullWorkspaceChangesFromCloud();
@@ -738,7 +1395,7 @@ describe('useSyncOrchestrator', () => {
             expect(pulled).toBe(false);
         });
         expect(runWorkspacePushSyncServiceMock).not.toHaveBeenCalled();
-        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(1);
+        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(pullCallsDuringRepair);
         await act(async () => {
             resolveRepairPull?.({
                 success: true,