@taskforcehq/taskforce 0.3.303 → 0.3.305

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

@@ -99,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',
@@ -298,6 +343,226 @@ describe('useSyncOrchestrator', () => {
         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({
@@ -349,19 +614,20 @@ describe('useSyncOrchestrator', () => {
         });
         expect(result.current.workspaceCloudSyncEnabled).toBe(true);
         expect(result.current.workspaceSyncPhase).toBe('provision-local');
+        runWorkspacePushSyncServiceMock.mockClear();
         await act(async () => {
             await result.current.pushWorkspaceChangesToCloud('sig-push-retry');
         });
-        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(1);
+        expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
         expect(result.current.isWorkspaceRetryPending()).toBe(true);
         await act(async () => {
             await result.current.pushWorkspaceChangesToCloud('sig-push-retry');
         });
         await waitFor(() => {
-            expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(2);
+            expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(2);
         });
         expect(result.current.workspaceSyncPhase).toBe('active');
-        expect(result.current.workspaceLastPushAt).toBe('2026-03-15T15:00:00.000Z');
+        expect(result.current.workspaceLastPushAt).toBeTruthy();
         await act(async () => {
             await Promise.resolve();
             await Promise.resolve();
@@ -391,7 +657,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()
         });
@@ -435,6 +714,223 @@ 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);
+        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('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,
@@ -506,6 +1002,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 = {
@@ -822,7 +1392,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();
@@ -830,7 +1401,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,
@@ -853,6 +1424,70 @@ describe('useSyncOrchestrator', () => {
         expect(result.current.workspaceLastPullAt).toBe('2026-03-15T21:05:00.000Z');
         unmount();
     });
+    it('periodically retries a stale local push signature even without a new state change', async () => {
+        vi.useFakeTimers();
+        const localTask = {
+            id: 'task-local-watchdog',
+            title: 'Watchdog push recovery',
+            status: 'task',
+            priority: 2,
+            complexity: 3,
+            type: 'feature',
+            category: 'general',
+            createdAt: '2026-03-15T18:00:00.000Z',
+            updatedAt: '2026-03-15T18:00:00.000Z',
+            comments: [],
+            attachments: [],
+            checklistItems: [],
+            taxonomies: {},
+            assignee: 'unassigned',
+            referenceNumber: null,
+            localReferenceNumber: 18
+        };
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({ tasks: [localTask] })
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await act(async () => {
+            await result.current.pushWorkspaceChangesToCloud('sig-initial-watchdog');
+        });
+        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(1);
+        runWorkspacePushSyncServiceMock.mockClear();
+        act(() => {
+            result.current.workspaceLastPushedSignatureRef.current = 'stale-signature';
+            result.current.workspacePullInFlightRef.current = true;
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(20_000);
+        });
+        expect(runWorkspacePushSyncServiceMock).not.toHaveBeenCalled();
+        act(() => {
+            result.current.workspacePullInFlightRef.current = false;
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(12_000);
+        });
+        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(1);
+        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledWith(expect.objectContaining({
+            payload: expect.objectContaining({
+                changes: expect.arrayContaining([
+                    expect.objectContaining({
+                        op: 'upsert',
+                        task: expect.objectContaining({
+                            id: 'task-local-watchdog'
+                        })
+                    })
+                ])
+            })
+        }));
+        unmount();
+    });
     it('forces a full ai-profile push during manual retry even when the workspace signature is unchanged', async () => {
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {