@taskforcehq/taskforce 0.3.306 → 0.3.307

package/dist/hooks/sync/transfers.test.js

@@ -46,9 +46,10 @@ function createCoordinator(overrides) {
         refreshWorkspaceSyncMarkdownDocumentsSnapshot: vi.fn(async () => { }),
         refreshWorkspaceSyncAiProfilesSnapshot: vi.fn(async () => { }),
         refreshWorkspaceSyncAssetsSnapshot: vi.fn(async () => { }),
+        refreshWorkspaceSyncPlanningEntitiesSnapshot: overrides?.refreshWorkspaceSyncPlanningEntitiesSnapshot ?? vi.fn(async () => { }),
         refreshWorkspaceSyncDocumentReviewSessionsSnapshot: vi.fn(async () => { }),
         refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: vi.fn(async () => { }),
-        refreshLocalWorkspaceTaskCollections: vi.fn(async () => { }),
+        refreshLocalWorkspaceTaskCollections: overrides?.refreshLocalWorkspaceTaskCollections ?? vi.fn(async () => { }),
         buildWorkspaceSyncPayload: (overrides?.buildWorkspaceSyncPayload ?? vi.fn(() => ({
             changes: [],
             currentTaskIds: new Set(),
@@ -77,7 +78,7 @@ function createCoordinator(overrides) {
             currentTaskEventWatermarks: new Map(),
             pushedWatermarks: new Map()
         }))),
-        buildWorkspaceSyncSignature: vi.fn(() => 'sync-signature'),
+        buildWorkspaceSyncSignature: overrides?.buildWorkspaceSyncSignature ?? vi.fn(() => 'sync-signature'),
         seedWorkspaceSnapshotPushBaseline: vi.fn(),
         shouldSuppressAttachBootstrapPush: vi.fn(() => false),
         recordSuppressedEventIds: vi.fn(),
@@ -136,6 +137,84 @@ describe('createWorkspaceTransferCoordinator', () => {
         runWorkspacePullSyncServiceMock.mockReset();
         runWorkspacePushSyncServiceMock.mockReset();
     });
+    it('refreshes planning entity snapshots before building a push payload', async () => {
+        const callOrder = [];
+        const refreshWorkspaceSyncPlanningEntitiesSnapshot = vi.fn(async () => {
+            callOrder.push('planning-refresh');
+        });
+        const buildWorkspaceSyncPayload = vi.fn(() => {
+            callOrder.push('build-payload');
+            return {
+                changes: [],
+                currentTaskIds: new Set(),
+                deleteTaskIds: new Set(),
+                currentInitiativeIds: new Set(),
+                currentInitiativeWatermarks: new Map(),
+                currentWorkstreamIds: new Set(),
+                currentWorkstreamWatermarks: new Map(),
+                currentAiProfileIds: new Set(),
+                currentAiProfileWatermarks: new Map(),
+                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(),
+                currentDocumentReviewCommentIds: new Set(),
+                deleteDocumentReviewCommentIds: new Set(),
+                currentDocumentReviewCommentWatermarks: new Map(),
+                currentAnnotatedAttachmentSessionIds: new Set(),
+                deleteAnnotatedAttachmentSessionIds: new Set(),
+                currentAnnotatedAttachmentSessionWatermarks: new Map(),
+                currentTaskEventWatermarks: new Map(),
+                pushedWatermarks: new Map()
+            };
+        });
+        runWorkspacePushSyncServiceMock.mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-04-27T16:00:00.000Z',
+            requestMs: 1,
+            changeCount: 0,
+            deleteCount: 0,
+            currentTaskIds: new Set(),
+            currentTaskWatermarks: new Map(),
+            currentTaskChangeKeys: new Map(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(),
+            currentAiProfileWatermarks: new Map(),
+            currentAiProfileChangeKeys: 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(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: [],
+            appliedTaskUpserts: []
+        });
+        const { coordinator } = createCoordinator({
+            buildWorkspaceSyncPayload,
+            refreshWorkspaceSyncPlanningEntitiesSnapshot
+        });
+        const result = await coordinator.pushWorkspaceChangesToCloud('signature-1');
+        expect(result).toBe(true);
+        expect(refreshWorkspaceSyncPlanningEntitiesSnapshot).toHaveBeenCalledTimes(1);
+        expect(buildWorkspaceSyncPayload).toHaveBeenCalledTimes(1);
+        expect(callOrder).toEqual(['planning-refresh', 'build-payload']);
+    });
     it('persists a cleared cursor before scheduling an invalid-cursor retry', async () => {
         runWorkspacePullSyncServiceMock.mockResolvedValueOnce({
             success: false,
@@ -162,6 +241,153 @@ describe('createWorkspaceTransferCoordinator', () => {
         expect(persistWorkspaceSyncPatchSafely).toHaveBeenCalledWith({ pullCursor: null });
         expect(scheduleWorkspaceSyncRetry).toHaveBeenCalledWith(150);
     });
+    it('refreshes local planning collections after planning-only pull changes', async () => {
+        const refreshLocalWorkspaceTaskCollections = vi.fn(async () => { });
+        runWorkspacePullSyncServiceMock.mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-04-27T22:00:00.000Z',
+            cursor: 'planning-cursor',
+            pages: 1,
+            appliedChanges: 1,
+            pullRequestMs: 1,
+            applyMs: 1,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            pulledTaskEventUpserts: false,
+            pulledPlanningUpserts: true,
+            documentDecryptFailures: [],
+            emittedEventIds: []
+        });
+        const { coordinator } = createCoordinator({ refreshLocalWorkspaceTaskCollections });
+        const result = await coordinator.pullWorkspaceChangesFromCloud();
+        expect(result).toBe(true);
+        expect(refreshLocalWorkspaceTaskCollections).toHaveBeenCalledTimes(1);
+    });
+    it('reasserts all AI profiles after a full reconcile pull', async () => {
+        vi.useFakeTimers();
+        runWorkspacePullSyncServiceMock.mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-03-15T19:30:00.000Z',
+            cursor: 'fresh-cursor',
+            pages: 1,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        runWorkspacePushSyncServiceMock.mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-03-15T19:30:01.000Z',
+            requestMs: 1,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(),
+            currentTaskWatermarks: new Map(),
+            currentTaskChangeKeys: new Map(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(['ai-profile-john-drake']),
+            currentAiProfileWatermarks: new Map([['ai-profile-john-drake', '2026-03-15T19:00:00.000Z']]),
+            currentAiProfileChangeKeys: new Map([['ai-profile-john-drake', 'john-change-key']]),
+            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(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: [],
+            appliedTaskUpserts: []
+        });
+        const buildWorkspaceSyncPayload = vi.fn(() => ({
+            changes: [{
+                    op: 'ai-profile-upsert',
+                    profile: {
+                        id: 'ai-profile-john-drake',
+                        workspaceId: 'workspace-local-active',
+                        profileToken: 'token-john',
+                        name: 'John Drake',
+                        username: 'john-drake',
+                        icon: 'Bot',
+                        color: '#8b5cf6',
+                        avatarUrl: null,
+                        avatarSourceUrl: null,
+                        description: null,
+                        role: null,
+                        provider: null,
+                        model: null,
+                        surfaceType: null,
+                        seatScope: null,
+                        providerMetadata: null,
+                        archivedAt: null,
+                        archivedBy: null,
+                        archivedReason: null,
+                        mergedIntoProfileId: null,
+                        rosterStateUpdatedAt: null,
+                        createdAt: '2026-03-15T19:00:00.000Z',
+                        updatedAt: '2026-03-15T19:00:00.000Z',
+                        lastActiveAt: null
+                    }
+                }],
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(['ai-profile-john-drake']),
+            currentAiProfileWatermarks: new Map([['ai-profile-john-drake', '2026-03-15T19:00:00.000Z']]),
+            currentAiProfileChangeKeys: new Map([['ai-profile-john-drake', 'john-change-key']]),
+            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(),
+            currentDocumentReviewCommentIds: new Set(),
+            deleteDocumentReviewCommentIds: new Set(),
+            currentDocumentReviewCommentWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            currentTaskEventWatermarks: new Map(),
+            pushedWatermarks: new Map()
+        }));
+        const { coordinator } = createCoordinator({ buildWorkspaceSyncPayload });
+        await coordinator.pullWorkspaceChangesFromCloud({ forceCursorNull: true });
+        await vi.advanceTimersByTimeAsync(130);
+        await Promise.resolve();
+        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledTimes(1);
+        expect(buildWorkspaceSyncPayload).toHaveBeenCalledWith({ forceAllAiProfiles: true });
+        expect(runWorkspacePushSyncServiceMock).toHaveBeenCalledWith(expect.objectContaining({
+            payload: expect.objectContaining({
+                changes: expect.arrayContaining([
+                    expect.objectContaining({
+                        op: 'ai-profile-upsert',
+                        profile: expect.objectContaining({
+                            id: 'ai-profile-john-drake',
+                            name: 'John Drake'
+                        })
+                    })
+                ])
+            })
+        }));
+    });
     it('reports push payload diagnostics when a push fails', async () => {
         runWorkspacePushSyncServiceMock.mockResolvedValueOnce({
             success: false,
@@ -393,4 +619,310 @@ describe('createWorkspaceTransferCoordinator', () => {
             })
         }));
     });
+    it('rebuilds a transient replay payload when refreshed sync state changes the signature before retry', async () => {
+        const stalePayload = {
+            changes: [{
+                    op: 'workstream-upsert',
+                    workstream: {
+                        id: 'workstream-1',
+                        referenceNumber: 701,
+                        title: 'Stale workstream',
+                        description: null,
+                        ownerId: null,
+                        initiativeId: null,
+                        createdAt: '2026-04-21T12:00:00.000Z',
+                        updatedAt: '2026-04-21T12:00:00.000Z',
+                        order: null,
+                        attachments: [],
+                        isArchived: false
+                    }
+                }],
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(['workstream-1']),
+            currentWorkstreamWatermarks: new Map([['workstream-1', '2026-04-21T12:00:00.000Z']]),
+            currentAiProfileIds: new Set(),
+            currentAiProfileWatermarks: new Map(),
+            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(),
+            currentDocumentReviewCommentIds: new Set(),
+            deleteDocumentReviewCommentIds: new Set(),
+            currentDocumentReviewCommentWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            currentTaskEventWatermarks: new Map(),
+            pushedWatermarks: new Map()
+        };
+        const refreshedPayload = {
+            ...stalePayload,
+            changes: [{
+                    op: 'workstream-upsert',
+                    workstream: {
+                        id: 'workstream-1',
+                        referenceNumber: 701,
+                        title: 'Stale workstream',
+                        description: null,
+                        ownerId: null,
+                        initiativeId: null,
+                        createdAt: '2026-04-21T12:00:00.000Z',
+                        updatedAt: '2026-04-21T12:00:05.000Z',
+                        order: null,
+                        attachments: [{
+                                path: '/api/taskforce/documents/asset-doc-1/content',
+                                fsPath: 'workspaces/workspace-local-active/assets/documents/doc-1.md',
+                                assetId: 'asset-doc-1',
+                                caption: 'Plan',
+                                timestamp: '2026-04-21T12:00:05.000Z'
+                            }],
+                        isArchived: false
+                    }
+                }],
+            currentWorkstreamWatermarks: new Map([['workstream-1', '2026-04-21T12:00:05.000Z']])
+        };
+        const buildWorkspaceSyncPayload = vi.fn()
+            .mockReturnValueOnce(stalePayload)
+            .mockReturnValueOnce(refreshedPayload);
+        const buildWorkspaceSyncSignature = vi.fn()
+            .mockReturnValueOnce('signature-stale')
+            .mockReturnValueOnce('signature-fresh')
+            .mockReturnValue('signature-fresh');
+        runWorkspacePushSyncServiceMock
+            .mockResolvedValueOnce({
+            success: false,
+            status: 524,
+            error: '524 unknown',
+            transient: true,
+            requestMs: 125000,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(['workstream-1']),
+            currentWorkstreamWatermarks: new Map([['workstream-1', '2026-04-21T12:00:00.000Z']]),
+            currentAiProfileIds: new Set(),
+            currentAiProfileWatermarks: new Map(),
+            currentDocumentPaths: new Set(),
+            deleteDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            deleteAssetPaths: 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(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: [],
+            appliedTaskUpserts: []
+        })
+            .mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-04-21T12:00:10.000Z',
+            requestMs: 200,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(['workstream-1']),
+            currentWorkstreamWatermarks: new Map([['workstream-1', '2026-04-21T12:00:05.000Z']]),
+            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(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: [],
+            appliedTaskUpserts: []
+        });
+        const { coordinator, reportSyncEvent } = createCoordinator({
+            buildWorkspaceSyncPayload,
+            buildWorkspaceSyncSignature
+        });
+        const firstResult = await coordinator.pushWorkspaceChangesToCloud('signature-stale');
+        const secondResult = await coordinator.pushWorkspaceChangesToCloud('signature-stale');
+        expect(firstResult).toBe(false);
+        expect(secondResult).toBe(true);
+        expect(buildWorkspaceSyncPayload).toHaveBeenCalledTimes(2);
+        expect(runWorkspacePushSyncServiceMock.mock.calls[0]?.[0]?.payload).toBe(stalePayload);
+        expect(runWorkspacePushSyncServiceMock.mock.calls[1]?.[0]?.payload).toBe(refreshedPayload);
+        expect(reportSyncEvent).toHaveBeenLastCalledWith('workspace-local-active', expect.objectContaining({
+            eventType: 'push',
+            status: 'success',
+            details: expect.objectContaining({
+                replayedPayload: false
+            })
+        }));
+    });
+    it('rebuilds a transient replay payload when a later retry forces all AI profiles', async () => {
+        const firstPayload = {
+            changes: [],
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(),
+            currentAiProfileWatermarks: new Map(),
+            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(),
+            currentDocumentReviewCommentIds: new Set(),
+            deleteDocumentReviewCommentIds: new Set(),
+            currentDocumentReviewCommentWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            currentTaskEventWatermarks: new Map(),
+            pushedWatermarks: new Map()
+        };
+        const forcedAiProfilePayload = {
+            ...firstPayload,
+            changes: [{
+                    op: 'ai-profile-upsert',
+                    profile: {
+                        id: 'ai-profile-codex',
+                        workspaceId: 'workspace-local-active',
+                        profileToken: 'tfp_codex',
+                        name: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#8b5cf6',
+                        avatarUrl: null,
+                        avatarSourceUrl: null,
+                        description: null,
+                        role: null,
+                        provider: null,
+                        model: null,
+                        surfaceType: null,
+                        seatScope: 'cloud_metered',
+                        providerMetadata: null,
+                        archivedAt: null,
+                        archivedBy: null,
+                        archivedReason: null,
+                        mergedIntoProfileId: null,
+                        rosterStateUpdatedAt: '2026-04-21T12:00:00.000Z',
+                        createdAt: '2026-04-21T12:00:00.000Z',
+                        updatedAt: '2026-04-21T12:00:00.000Z',
+                        lastActiveAt: null
+                    }
+                }],
+            currentAiProfileIds: new Set(['ai-profile-codex']),
+            currentAiProfileWatermarks: new Map([['ai-profile-codex', '2026-04-21T12:00:00.000Z']]),
+            currentAiProfileChangeKeys: new Map([['ai-profile-codex', 'codex-change-key']])
+        };
+        const buildWorkspaceSyncPayload = vi.fn()
+            .mockReturnValueOnce(firstPayload)
+            .mockReturnValueOnce(forcedAiProfilePayload);
+        runWorkspacePushSyncServiceMock
+            .mockResolvedValueOnce({
+            success: false,
+            status: 524,
+            error: '524 unknown',
+            transient: true,
+            requestMs: 125000,
+            changeCount: 0,
+            deleteCount: 0,
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(),
+            currentAiProfileWatermarks: new Map(),
+            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(),
+            currentDocumentReviewCommentIds: new Set(),
+            deleteDocumentReviewCommentIds: new Set(),
+            currentDocumentReviewCommentWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            currentTaskEventWatermarks: new Map(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: [],
+            appliedTaskUpserts: []
+        })
+            .mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-04-21T12:00:00.000Z',
+            requestMs: 200,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(),
+            currentTaskWatermarks: new Map(),
+            currentTaskChangeKeys: new Map(),
+            deleteTaskIds: new Set(),
+            currentInitiativeIds: new Set(),
+            currentInitiativeWatermarks: new Map(),
+            currentWorkstreamIds: new Set(),
+            currentWorkstreamWatermarks: new Map(),
+            currentAiProfileIds: new Set(['ai-profile-codex']),
+            currentAiProfileWatermarks: new Map([['ai-profile-codex', '2026-04-21T12:00:00.000Z']]),
+            currentAiProfileChangeKeys: new Map([['ai-profile-codex', 'codex-change-key']]),
+            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(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: [],
+            appliedTaskUpserts: []
+        });
+        const { coordinator } = createCoordinator({ buildWorkspaceSyncPayload });
+        const firstResult = await coordinator.pushWorkspaceChangesToCloud('signature-1');
+        const secondResult = await coordinator.pushWorkspaceChangesToCloud('signature-1', { forceAllAiProfiles: true });
+        expect(firstResult).toBe(false);
+        expect(secondResult).toBe(true);
+        expect(buildWorkspaceSyncPayload).toHaveBeenCalledTimes(2);
+        expect(buildWorkspaceSyncPayload).toHaveBeenNthCalledWith(1, { forceAllAiProfiles: false });
+        expect(buildWorkspaceSyncPayload).toHaveBeenNthCalledWith(2, { forceAllAiProfiles: true });
+        expect(runWorkspacePushSyncServiceMock.mock.calls[0]?.[0]?.payload).toBe(firstPayload);
+        expect(runWorkspacePushSyncServiceMock.mock.calls[1]?.[0]?.payload).toBe(forcedAiProfilePayload);
+    });
 });

package/dist/hooks/useFilterSort.js

@@ -25,7 +25,7 @@ import { DEFAULT_TYPE_VALUE } from '../shared/taxonomyDefaults.js';
 import { STATUS_OPTIONS } from '../utils/constants';
 import { normalizeAssigneeOptions } from '../utils/assignees';
 import { matchesPriorityFilter, normalizeCategoryFilters, normalizePriorityFilterValues } from '../utils/taskNormalization.js';
-import { getTaskReferenceLabel } from '../utils/taskReferences';
+import { normalizeTaskSearchQuery, taskMatchesSearch } from '../utils/taskSearch';
 import { compareTasksBySortKey } from '../utils/taxonomySorting.js';
 import { getFilterVisibleTaxonomyOptions } from '../utils/taxonomyFilterOptions.js';
 import { getVisibleTaxonomiesForTasks } from '../utils/taxonomyLifecycle.js';
@@ -211,17 +211,21 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
         });
     }, [assigneeFilterValues]);
     // === SECTION: Derived Collections ===
+    const normalizedSearchQuery = useMemo(() => normalizeTaskSearchQuery(searchQuery), [searchQuery]);
+    const taskSearchContext = useMemo(() => ({
+        categories: activeCategories,
+        types: activeTypes,
+        priorities,
+        assigneeOptions: resolvedAssigneeOptions,
+        taxonomies
+    }), [activeCategories, activeTypes, priorities, resolvedAssigneeOptions, taxonomies]);
     const filteredTasks = useMemo(() => {
         const isAllCategoriesSelected = isAllFilterValuesSelected(filterCategories, activeCategories.map((category) => category.value));
         const isAllTypesSelected = isAllFilterValuesSelected(filterTypes, activeTypes.map((type) => type.value));
         const isAllPrioritiesSelected = isAllFilterValuesSelected(Array.from(new Set(filterPriorities.map((value) => Number(value)).filter((value) => Number.isFinite(value)))), priorities.map((priority) => Number(priority.value)).filter((value) => Number.isFinite(value)));
         const isAllStatusesSelected = isAllFilterValuesSelected(filterStatus, STATUS_OPTIONS.map((status) => status.value));
         return tasks.filter(t => {
-            const referenceLabel = getTaskReferenceLabel(t).toLowerCase();
-            const matchSearch = (t.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
-                (t.description?.toLowerCase() || '').includes(searchQuery.toLowerCase()) ||
-                t.id.toLowerCase().includes(searchQuery.toLowerCase()) ||
-                referenceLabel.includes(searchQuery.toLowerCase()));
+            const matchSearch = taskMatchesSearch(t, normalizedSearchQuery, taskSearchContext);
             const matchCategory = !hasInitedFilters || isAllCategoriesSelected || filterCategories.includes(t.category);
             const matchPriority = !hasInitedFilters || isAllPrioritiesSelected || matchesPriorityFilter(t.priority, filterPriorities);
             const matchType = !hasInitedFilters || isAllTypesSelected || filterTypes.includes(t.type || DEFAULT_TYPE_VALUE);
@@ -245,7 +249,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             });
             return matchSearch && matchCategory && matchPriority && matchType && matchStatus && matchAssignee && matchTaxonomies;
         }).sort((a, b) => compareTasksBySortKey(a, b, sortBy, sortOrder, taxonomies));
-    }, [tasks, archivedTasks, searchQuery, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, filterableTaxonomies, activeCategories, activeTypes, priorities, isAllFilterValuesSelected, taxonomies]);
+    }, [tasks, archivedTasks, normalizedSearchQuery, taskSearchContext, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, filterableTaxonomies, activeCategories, activeTypes, priorities, isAllFilterValuesSelected, taxonomies]);
     const searchAgnosticTasks = useMemo(() => {
         const isAllCategoriesSelected = isAllFilterValuesSelected(filterCategories, activeCategories.map((category) => category.value));
         const isAllTypesSelected = isAllFilterValuesSelected(filterTypes, activeTypes.map((type) => type.value));
@@ -280,11 +284,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
         const isAllTypesSelected = isAllFilterValuesSelected(filterTypes, activeTypes.map((type) => type.value));
         const isAllPrioritiesSelected = isAllFilterValuesSelected(Array.from(new Set(filterPriorities.map((value) => Number(value)).filter((value) => Number.isFinite(value)))), priorities.map((priority) => Number(priority.value)).filter((value) => Number.isFinite(value)));
         return archivedTasks.filter(t => {
-            const referenceLabel = getTaskReferenceLabel(t).toLowerCase();
-            const matchSearch = (t.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
-                (t.description?.toLowerCase() || '').includes(searchQuery.toLowerCase()) ||
-                t.id.toLowerCase().includes(searchQuery.toLowerCase()) ||
-                referenceLabel.includes(searchQuery.toLowerCase()));
+            const matchSearch = taskMatchesSearch(t, normalizedSearchQuery, taskSearchContext);
             const matchCategory = !hasInitedFilters || isAllCategoriesSelected || filterCategories.includes(t.category);
             const matchPriority = !hasInitedFilters || isAllPrioritiesSelected || matchesPriorityFilter(t.priority, filterPriorities);
             const matchType = !hasInitedFilters || isAllTypesSelected || filterTypes.includes(t.type || DEFAULT_TYPE_VALUE);
@@ -306,7 +306,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             });
             return matchSearch && matchCategory && matchPriority && matchType && matchAssignee && matchTaxonomies;
         }).sort((a, b) => compareTasksBySortKey(a, b, sortBy, sortOrder, taxonomies));
-    }, [archivedTasks, searchQuery, filterCategories, filterPriorities, filterTypes, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, activeCategories, activeTypes, priorities, filterableTaxonomies, isAllFilterValuesSelected, taxonomies]);
+    }, [archivedTasks, normalizedSearchQuery, taskSearchContext, filterCategories, filterPriorities, filterTypes, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, activeCategories, activeTypes, priorities, filterableTaxonomies, isAllFilterValuesSelected, taxonomies]);
     const groupedTasks = useMemo(() => {
         const groups = {};
         filteredTasks.forEach(task => {