@taskforcehq/taskforce 0.3.311 → 0.3.313

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

@@ -1,2027 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-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() {
-        this.readyState = MockWebSocket.CLOSED;
-        this.emit('close', {});
-    }
-    addEventListener(type, listener) {
-        const bucket = this.listeners.get(type) || new Set();
-        bucket.add(listener);
-        this.listeners.set(type, bucket);
-    }
-    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(() => ({
-    ensureCloudWorkspaceReadyForSyncServiceMock: vi.fn(),
-    runWorkspacePullSyncServiceMock: vi.fn(),
-    runWorkspacePushSyncServiceMock: vi.fn(),
-    syncUserGlobalSettingsServiceMock: vi.fn()
-}));
-vi.mock('../sync/syncService', async () => {
-    const actual = await vi.importActual('../sync/syncService');
-    return {
-        ...actual,
-        calculateWorkspaceRetryDelayMs: vi.fn(() => 100),
-        ensureCloudWorkspaceReadyForSyncService: ensureCloudWorkspaceReadyForSyncServiceMock,
-        runWorkspacePullSyncService: runWorkspacePullSyncServiceMock,
-        runWorkspacePushSyncService: runWorkspacePushSyncServiceMock,
-        syncUserGlobalSettingsService: syncUserGlobalSettingsServiceMock
-    };
-});
-function buildInput(overrides) {
-    return {
-        currentWorkspaceId: 'workspace-local-active',
-        cloudAuthConfigured: true,
-        runtimeMode: 'local',
-        authSessionResolved: true,
-        isAuthenticated: true,
-        authUserId: 'user-1',
-        projectName: 'Test Project',
-        resolveCloudAuthUrl: (path) => `https://cloud.example.com${path}`,
-        resolveWebSocketUrl: (path) => `wss://api.example.com${path}`,
-        realtimeSyncEnabled: false,
-        tasks: [],
-        archivedTasks: [],
-        initiatives: [],
-        workstreams: [],
-        taxonomies: [],
-        setupState: null,
-        globalTheme: 'dark',
-        locale: 'en-US',
-        globalWeekStartsOn: 'monday',
-        themeUseGlobalDefault: true,
-        setTasks: vi.fn(),
-        setArchivedTasks: vi.fn(),
-        setAuthBlocked: vi.fn(),
-        setIsAuthenticated: vi.fn(),
-        checkAuthSession: vi.fn(async () => true),
-        setGlobalTheme: vi.fn(),
-        setCurrentTheme: vi.fn(),
-        setSetupState: vi.fn(),
-        setLocale: vi.fn(),
-        setGlobalWeekStartsOn: vi.fn(),
-        fetchPlanningEntities: vi.fn(async () => { }),
-        ...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',
-            updatedAt: new Date().toISOString()
-        });
-        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,
-                            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 }) });
-        }));
-    });
-    afterEach(async () => {
-        await Promise.resolve();
-        await Promise.resolve();
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-        vi.clearAllMocks();
-        MockWebSocket.instances = [];
-    });
-    it('uses the latest retry callback after auth state changes', async () => {
-        vi.useFakeTimers();
-        runWorkspacePullSyncServiceMock.mockResolvedValue({
-            success: false,
-            kind: 'pull_http',
-            status: 503,
-            transient: true,
-            retryAfterMs: 250,
-            cursor: null,
-            pages: 0,
-            appliedChanges: 0,
-            pullRequestMs: 1,
-            applyMs: 0,
-            pulledDeleteTaskIds: new Set(),
-            pulledActiveUpserts: false,
-            pulledArchivedUpserts: false
-        });
-        let input = buildInput();
-        const { result, rerender, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: input
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'active',
-                pullCursor: null
-            });
-        });
-        await act(async () => {
-            await result.current.pullWorkspaceChangesFromCloud();
-        });
-        const pullCallsBeforeRetry = runWorkspacePullSyncServiceMock.mock.calls.length;
-        expect(pullCallsBeforeRetry).toBeGreaterThanOrEqual(1);
-        expect(result.current.workspaceRetryAt).not.toBeNull();
-        input = buildInput({
-            isAuthenticated: false,
-            checkAuthSession: vi.fn(async () => false)
-        });
-        rerender(input);
-        await act(async () => {
-            await vi.runOnlyPendingTimersAsync();
-        });
-        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(pullCallsBeforeRetry);
-        unmount();
-    });
-    it('does not enable realtime until auth session is resolved with a non-anonymous user', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const { result, rerender, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput({
-                realtimeSyncEnabled: true,
-                authSessionResolved: false,
-                authUserId: 'anonymous'
-            })
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'active',
-                pullCursor: null
-            });
-        });
-        expect(MockWebSocket.instances).toHaveLength(0);
-        rerender(buildInput({
-            realtimeSyncEnabled: true,
-            authSessionResolved: true,
-            authUserId: 'anonymous'
-        }));
-        expect(MockWebSocket.instances).toHaveLength(0);
-        rerender(buildInput({
-            realtimeSyncEnabled: true,
-            authSessionResolved: true,
-            authUserId: 'user-1'
-        }));
-        await waitFor(() => {
-            expect(MockWebSocket.instances).toHaveLength(1);
-        });
-        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({
-            success: false,
-            status: 503,
-            transient: true,
-            retryAfterMs: 200,
-            requestMs: 1,
-            changeCount: 1,
-            deleteCount: 0,
-            currentTaskIds: new Set(),
-            deleteTaskIds: new Set(),
-            currentDocumentPaths: new Set(),
-            deleteDocumentPaths: new Set(),
-            currentDocumentWatermarks: new Map(),
-            pushedWatermarks: new Map(),
-            emittedEventIds: []
-        })
-            .mockResolvedValueOnce({
-            success: true,
-            syncedAt: '2026-03-15T15:00:00.000Z',
-            requestMs: 1,
-            changeCount: 1,
-            deleteCount: 0,
-            currentTaskIds: new Set(['task-1']),
-            deleteTaskIds: new Set(),
-            currentDocumentPaths: new Set(),
-            deleteDocumentPaths: new Set(),
-            currentDocumentWatermarks: new Map(),
-            pushedWatermarks: new Map([['task-1', '2026-03-14T12:00:00.000Z']]),
-            emittedEventIds: []
-        });
-        const task = {
-            id: 'task-1',
-            status: 'task',
-            title: 'Retry me',
-            createdAt: '2026-03-14T12:00:00.000Z',
-            updatedAt: '2026-03-14T12:00:00.000Z'
-        };
-        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput({ tasks: [task] })
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'provision-local',
-                pullCursor: null
-            });
-        });
-        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.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.mock.calls.length).toBeGreaterThanOrEqual(2);
-        });
-        expect(result.current.workspaceSyncPhase).toBe('active');
-        expect(result.current.workspaceLastPushAt).toBeTruthy();
-        await act(async () => {
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        unmount();
-    });
-    it('keeps the last workspace error visible while a retry attempt is in flight', async () => {
-        let resolveRetryPull = null;
-        runWorkspacePullSyncServiceMock
-            .mockResolvedValueOnce({
-            success: false,
-            kind: 'apply_all_candidates',
-            status: 400,
-            transient: true,
-            hasTransientApplyFailure: true,
-            error: 'Apply failed during bootstrap',
-            failures: ['/api/taskforce/sync/workspace/apply-local:400'],
-            cursor: null,
-            pages: 0,
-            appliedChanges: 0,
-            pullRequestMs: 1,
-            applyMs: 1,
-            pulledDeleteTaskIds: new Set(),
-            pulledActiveUpserts: false,
-            pulledArchivedUpserts: false,
-            documentDecryptFailures: []
-        })
-            .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()
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'attach-cloud',
-                pullCursor: null
-            });
-        });
-        await waitFor(() => {
-            expect(result.current.workspaceLastErrorMessage).toBe('Apply failed during bootstrap');
-            expect(result.current.isWorkspaceRetryPending()).toBe(true);
-        });
-        act(() => {
-            void result.current.retryWorkspaceCloudSync();
-        });
-        await waitFor(() => {
-            expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(2);
-            expect(result.current.workspaceSyncBusy).toBe(true);
-            expect(result.current.workspaceLastErrorMessage).toBe('Apply failed during bootstrap');
-        });
-        await act(async () => {
-            resolveRetryPull?.({
-                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: []
-            });
-        });
-        await waitFor(() => {
-            expect(result.current.workspaceSyncBusy).toBe(false);
-            expect(result.current.workspaceLastPullAt).toBe('2026-03-15T19:30:00.000Z');
-        });
-        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);
-        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();
-    });
-    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('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({
-            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('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,
-            syncedAt: '2026-03-15T18:00:00.000Z',
-            requestMs: 1,
-            changeCount: 0,
-            deleteCount: 0,
-            currentTaskIds: new Set(),
-            deleteTaskIds: new Set(),
-            currentDocumentPaths: new Set(),
-            deleteDocumentPaths: new Set(),
-            currentDocumentWatermarks: new Map(),
-            pushedWatermarks: new Map(),
-            emittedEventIds: []
-        });
-        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput()
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'provision-local',
-                pullCursor: null
-            });
-        });
-        await waitFor(() => {
-            expect(result.current.workspaceSyncPhase).toBe('provision-local');
-        });
-        await act(async () => {
-            await result.current.pushWorkspaceChangesToCloud('sig-bootstrap');
-        });
-        await waitFor(() => {
-            expect(result.current.workspaceSyncPhase).toBe('active');
-            expect(result.current.workspaceLastPushAt).toBe('2026-03-15T18:00:00.000Z');
-        });
-        await act(async () => {
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        unmount();
-    });
-    it('finishes attach-cloud bootstrap after the first successful pull, including zero-change pulls', 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()
-        });
-        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: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 () => {
-        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 = {
-            id: 'task-1',
-            status: 'task',
-            title: 'Local stale task',
-            createdAt: '2026-03-14T12:00:00.000Z',
-            updatedAt: '2026-03-14T12:00:00.000Z'
-        };
-        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: 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 }) });
-        }));
-        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: [task] })
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'attach-cloud',
-                pullCursor: null
-            });
-        });
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(2000);
-        });
-        expect(result.current.workspaceSyncPhase).toBe('active');
-        expect(runWorkspacePushSyncServiceMock).not.toHaveBeenCalled();
-        unmount();
-    });
-    it('prevents duplicate local windows from running the same pull concurrently', async () => {
-        let resolveFirstPull = null;
-        runWorkspacePullSyncServiceMock.mockImplementationOnce(() => new Promise((resolve) => {
-            resolveFirstPull = resolve;
-        }));
-        const firstHook = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput()
-        });
-        const secondHook = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput()
-        });
-        act(() => {
-            firstHook.result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'active',
-                pullCursor: null
-            });
-        });
-        await waitFor(() => {
-            expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(firstHook.result.current.workspaceSyncBusy).toBe(true);
-        });
-        const callsWhileFirstWindowOwnsLease = runWorkspacePullSyncServiceMock.mock.calls.length;
-        act(() => {
-            secondHook.result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'active',
-                pullCursor: null
-            });
-        });
-        await waitFor(() => {
-            expect(secondHook.result.current.workspaceLastErrorMessage).toMatch(/another local window/i);
-        });
-        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(callsWhileFirstWindowOwnsLease);
-        await act(async () => {
-            resolveFirstPull?.({
-                success: true,
-                syncedAt: '2026-03-15T20:00:00.000Z',
-                cursor: null,
-                pages: 1,
-                appliedChanges: 0,
-                pullRequestMs: 1,
-                applyMs: 0,
-                pulledDeleteTaskIds: new Set(),
-                pulledActiveUpserts: false,
-                pulledArchivedUpserts: false,
-                documentDecryptFailures: []
-            });
-        });
-        firstHook.unmount();
-        secondHook.unmount();
-    });
-    it('marks stalled bootstrap as error and keeps repair actionable', async () => {
-        vi.useFakeTimers();
-        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput({
-                isAuthenticated: false,
-                checkAuthSession: vi.fn(async () => false)
-            })
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'attach-cloud',
-                pullCursor: null
-            });
-        });
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(130_000);
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        expect(result.current.workspaceSyncPhase).toBe('error');
-        expect(result.current.workspaceLastErrorMessage).toMatch(/stalled/i);
-        expect(result.current.workspaceSyncRecommendedAction).toMatch(/repair/i);
-        unmount();
-    });
-    it('does not mark bootstrap stalled while pull is slow but making progress', async () => {
-        vi.useFakeTimers();
-        runWorkspacePullSyncServiceMock.mockImplementation(async (input) => {
-            input.onPagePulled?.();
-            await new Promise((resolve) => {
-                setTimeout(resolve, 70_000);
-            });
-            input.onChangesApplied?.(200);
-            await new Promise((resolve) => {
-                setTimeout(resolve, 70_000);
-            });
-            return {
-                success: true,
-                syncedAt: '2026-03-15T20:30:00.000Z',
-                cursor: null,
-                pages: 2,
-                appliedChanges: 200,
-                pullRequestMs: 140_000,
-                applyMs: 100,
-                pulledDeleteTaskIds: new Set(),
-                pulledActiveUpserts: true,
-                pulledArchivedUpserts: false,
-                documentDecryptFailures: []
-            };
-        });
-        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput()
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'attach-cloud',
-                pullCursor: null
-            });
-        });
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(130_000);
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        expect(result.current.workspaceSyncPhase).toBe('attach-cloud');
-        expect(result.current.workspaceLastErrorMessage).toBeNull();
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(20_000);
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        expect(result.current.workspaceSyncPhase).toBe('active');
-        expect(result.current.workspaceLastPullAt).toBe('2026-03-15T20:30:00.000Z');
-        unmount();
-    });
-    it('does not mark bootstrap stalled while the first pull page is still in flight without progress callbacks yet', async () => {
-        vi.useFakeTimers();
-        let resolvePull = null;
-        runWorkspacePullSyncServiceMock.mockImplementation(() => new Promise((resolve) => {
-            resolvePull = resolve;
-        }));
-        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput()
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'attach-cloud',
-                pullCursor: null
-            });
-        });
-        await act(async () => {
-            await vi.advanceTimersByTimeAsync(130_000);
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        expect(result.current.workspaceSyncPhase).toBe('attach-cloud');
-        expect(result.current.workspaceLastErrorMessage).toBeNull();
-        await act(async () => {
-            resolvePull?.({
-                success: true,
-                syncedAt: '2026-03-15T20:45:00.000Z',
-                cursor: null,
-                pages: 1,
-                appliedChanges: 0,
-                pullRequestMs: 130_000,
-                applyMs: 0,
-                pulledDeleteTaskIds: new Set(),
-                pulledActiveUpserts: false,
-                pulledArchivedUpserts: false,
-                documentDecryptFailures: []
-            });
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        expect(result.current.workspaceSyncPhase).toBe('active');
-        expect(result.current.workspaceLastPullAt).toBe('2026-03-15T20:45:00.000Z');
-        unmount();
-    });
-    it('repair resets bootstrap state and retries attach-cloud deterministically', async () => {
-        runWorkspacePullSyncServiceMock.mockResolvedValue({
-            success: true,
-            syncedAt: '2026-03-15T21: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()
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'attach-cloud',
-                pullCursor: 'stale-cursor'
-            });
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'error',
-                pullCursor: 'stale-cursor',
-                lastErrorMessage: 'Workspace sync initial cloud pull stalled. Press Repair to restart sync for this workspace.'
-            });
-        });
-        await act(async () => {
-            await result.current.resetWorkspaceSyncCursorAndPull();
-        });
-        expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-        expect(runWorkspacePushSyncServiceMock).not.toHaveBeenCalled();
-        expect(result.current.workspacePullCursorRef.current).toBeNull();
-        expect(result.current.workspaceSyncPhase).toBe('active');
-        expect(result.current.workspaceLastPullAt).toBe('2026-03-15T21:00:00.000Z');
-        unmount();
-    });
-    it('blocks same-window push and pull reentry while repair is active', async () => {
-        let resolveRepairPull = null;
-        runWorkspacePullSyncServiceMock.mockImplementationOnce(() => new Promise((resolve) => {
-            resolveRepairPull = resolve;
-        }));
-        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: buildInput()
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'attach-cloud',
-                pullCursor: 'stale-cursor'
-            });
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'error',
-                pullCursor: 'stale-cursor',
-                lastErrorMessage: 'Workspace sync initial cloud pull stalled. Press Repair to restart sync for this workspace.'
-            });
-        });
-        let repairPromise = null;
-        await act(async () => {
-            repairPromise = result.current.resetWorkspaceSyncCursorAndPull();
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        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();
-            expect(pushed).toBe(false);
-            expect(pulled).toBe(false);
-        });
-        expect(runWorkspacePushSyncServiceMock).not.toHaveBeenCalled();
-        expect(runWorkspacePullSyncServiceMock).toHaveBeenCalledTimes(pullCallsDuringRepair);
-        await act(async () => {
-            resolveRepairPull?.({
-                success: true,
-                syncedAt: '2026-03-15T21:05:00.000Z',
-                cursor: null,
-                pages: 1,
-                appliedChanges: 0,
-                pullRequestMs: 1,
-                applyMs: 0,
-                pulledDeleteTaskIds: new Set(),
-                pulledActiveUpserts: false,
-                pulledArchivedUpserts: false,
-                documentDecryptFailures: []
-            });
-            await repairPromise;
-            await Promise.resolve();
-            await Promise.resolve();
-        });
-        expect(result.current.workspaceSyncPhase).toBe('active');
-        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')) {
-                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/ai-profiles')) {
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        aiProfiles: [{
-                                id: 'ai-profile-codex',
-                                workspaceId: 'workspace-local-active',
-                                profileToken: 'token-codex',
-                                name: 'Codex',
-                                username: 'codex',
-                                icon: 'Bot',
-                                color: '#0ea5e9',
-                                createdAt: '2026-03-15T18:00:00.000Z',
-                                updatedAt: '2026-03-15T18:00:00.000Z',
-                                lastActiveAt: '2026-03-15T18:00:00.000Z'
-                            }]
-                    })
-                });
-            }
-            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/workspace/assets')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ assets: [] }) });
-            }
-            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-15T22:00: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-15T22:00:01.000Z',
-            requestMs: 1,
-            changeCount: 1,
-            deleteCount: 0,
-            currentTaskIds: new Set(),
-            deleteTaskIds: new Set(),
-            currentAiProfileIds: new Set(['ai-profile-codex']),
-            currentAiProfileWatermarks: new Map([['ai-profile-codex', '2026-03-15T18:00:00.000Z']]),
-            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()
-        });
-        runWorkspacePushSyncServiceMock.mockClear();
-        await act(async () => {
-            await result.current.retryWorkspaceCloudSync();
-        });
-        await waitFor(() => {
-            expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-        });
-        const retryPayloads = runWorkspacePushSyncServiceMock.mock.calls
-            .map((call) => call?.[0]?.payload)
-            .filter(Boolean);
-        expect(retryPayloads).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                changes: expect.arrayContaining([
-                    expect.objectContaining({
-                        op: 'ai-profile-upsert',
-                        profile: expect.objectContaining({
-                            id: 'ai-profile-codex',
-                            workspaceId: 'workspace-local-active',
-                            name: 'Codex'
-                        })
-                    })
-                ])
-            })
-        ]));
-        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();
-    });
-});