@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/sync/syncApplyHandlers.test.js

@@ -1,626 +0,0 @@
-import fs from 'node:fs';
-import { createHash } from 'node:crypto';
-import { describe, expect, it, vi, afterEach } from 'vitest';
-import { applyCollaborationSyncChanges, applyContentSyncChanges, applyPlanningSyncChanges, applyPreparedTaskSyncSnapshot, applyTaskActivitySyncChanges, applyTaskSyncDeletes, classifyWorkspaceSyncChanges, prepareTaskSyncSnapshotApply, } from './syncApplyHandlers.js';
-function createCoreFixture(overrides = {}) {
-    return {
-        resolveTaskIdentifier: vi.fn().mockReturnValue(null),
-        getTask: vi.fn().mockReturnValue(null),
-        taskExistsForSync: vi.fn().mockReturnValue(true),
-        initiativeExistsForSync: vi.fn().mockReturnValue(true),
-        workstreamExistsForSync: vi.fn().mockReturnValue(true),
-        getTaskEventForSync: vi.fn().mockReturnValue(null),
-        getEntityEventForSync: vi.fn().mockReturnValue(null),
-        deleteTaskForSync: vi.fn(),
-        applyWorkspaceSyncSnapshot: vi.fn().mockReturnValue({
-            total: 1,
-            created: 0,
-            updated: 1,
-            archived: 0,
-            unarchived: 0,
-            skipped: 0,
-        }),
-        notifyDocumentMetadataMutation: vi.fn(),
-        getDocumentWatermark: vi.fn().mockReturnValue(null),
-        getTenantId: vi.fn().mockReturnValue('tenant-1'),
-        getDocumentReviewSession: vi.fn().mockReturnValue(null),
-        upsertDocumentReviewSessionForSync: vi.fn(),
-        listDocumentReviewCommentsForSync: vi.fn().mockReturnValue([]),
-        upsertDocumentReviewCommentForSync: vi.fn(),
-        deleteDocumentReviewSessionForSync: vi.fn(),
-        deleteDocumentReviewCommentForSync: vi.fn(),
-        getAnnotatedAttachmentSession: vi.fn().mockReturnValue(null),
-        upsertAnnotatedAttachmentSessionForSync: vi.fn(),
-        deleteAnnotatedAttachmentSessionForSync: vi.fn(),
-        ...overrides,
-    };
-}
-describe('syncApplyHandlers', () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('classifies task and workstream changes, then prepares and applies the task snapshot pipeline', () => {
-        const diagnostics = [];
-        const workspaceId = 'workspace-1';
-        const applyModel = classifyWorkspaceSyncChanges({
-            workspaceId,
-            incomingChanges: [
-                {
-                    op: 'workstream-upsert',
-                    workstream: {
-                        id: 'workstream-1',
-                        title: 'Delivery',
-                        description: null,
-                        createdAt: '2026-04-10T09:00:00.000Z',
-                        updatedAt: '2026-04-10T09:00:00.000Z',
-                    },
-                },
-                {
-                    op: 'upsert',
-                    archived: false,
-                    task: {
-                        id: 'task-1',
-                        title: 'Superseded task',
-                        status: 'task',
-                        category: 'general',
-                        type: 'feature',
-                        createdAt: '2026-04-10T09:00:00.000Z',
-                        updatedAt: '2026-04-10T10:00:00.000Z',
-                        referenceNumber: 7,
-                    },
-                },
-                {
-                    op: 'upsert',
-                    archived: true,
-                    task: {
-                        id: 'task-2',
-                        title: 'Archived task',
-                        status: 'done',
-                        category: 'general',
-                        type: 'feature',
-                        createdAt: '2026-04-10T09:00:00.000Z',
-                        updatedAt: '2026-04-10T10:30:00.000Z',
-                        isArchived: true,
-                    },
-                },
-                {
-                    op: 'delete',
-                    taskId: 'task-1',
-                    deletedAt: '2026-04-10T11:00:00.000Z',
-                },
-                {
-                    op: 'delete',
-                    taskId: 'task-stale',
-                    deletedAt: '2026-04-10T08:00:00.000Z',
-                },
-            ],
-            normalizeWorkspaceSyncDocumentPath: (rawPath) => typeof rawPath === 'string' ? rawPath : null,
-            normalizeTaskAssetPath: (rawPath) => typeof rawPath === 'string' ? rawPath : null,
-            normalizeIncomingAiProfileSurfaceType: () => null,
-            normalizeIncomingAiProfileSeatScope: () => null,
-            normalizeTaskEventSyncPayload: () => null,
-            recordSyncDiagnostic: (targetWorkspaceId, eventType, message, details) => {
-                diagnostics.push({ workspaceId: targetWorkspaceId, eventType, message, details });
-            },
-        });
-        expect(applyModel.planning.incomingWorkstreams.get('workstream-1')).toEqual(expect.objectContaining({
-            id: 'workstream-1',
-            title: 'Delivery',
-        }));
-        expect(applyModel.taskMutations.upserts).toHaveLength(2);
-        expect(applyModel.taskMutations.deletes.get('task-1')).toBe('2026-04-10T11:00:00.000Z');
-        const core = createCoreFixture({
-            resolveTaskIdentifier: vi.fn().mockReturnValue({
-                id: 'task-local-7',
-                title: 'Local incumbent',
-                referenceNumber: 7,
-            }),
-            getTask: vi.fn().mockImplementation((taskId) => {
-                if (taskId === 'task-1') {
-                    return {
-                        id: 'task-1',
-                        title: 'Superseded task',
-                        createdAt: '2026-04-10T09:00:00.000Z',
-                        updatedAt: '2026-04-10T10:00:00.000Z',
-                        isArchived: false,
-                    };
-                }
-                if (taskId === 'task-stale') {
-                    return {
-                        id: 'task-stale',
-                        title: 'Keep local task',
-                        createdAt: '2026-04-10T09:00:00.000Z',
-                        updatedAt: '2026-04-10T09:30:00.000Z',
-                        isArchived: false,
-                    };
-                }
-                return null;
-            }),
-        });
-        const prepared = prepareTaskSyncSnapshotApply({
-            core,
-            workspaceId,
-            taskMutations: applyModel.taskMutations,
-            recordSyncDiagnostic: (targetWorkspaceId, eventType, message, details) => {
-                diagnostics.push({ workspaceId: targetWorkspaceId, eventType, message, details });
-            },
-        });
-        expect(prepared.tasks).toEqual([]);
-        expect(prepared.archived).toEqual([
-            expect.objectContaining({
-                id: 'task-2',
-                title: 'Archived task',
-            }),
-        ]);
-        expect(diagnostics).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                workspaceId,
-                eventType: 'apply',
-                message: 'Detected task reference number mismatch during normal sync.',
-                details: expect.objectContaining({
-                    referenceLabel: 'T-7',
-                    existingTaskId: 'task-local-7',
-                    taskId: 'task-1',
-                }),
-            }),
-        ]));
-        const deleteCount = applyTaskSyncDeletes({
-            core,
-            workspaceId,
-            taskMutations: applyModel.taskMutations,
-            recordSyncDiagnostic: vi.fn(),
-        });
-        expect(deleteCount).toBe(2);
-        expect(core.deleteTaskForSync).toHaveBeenCalledTimes(1);
-        expect(core.deleteTaskForSync).toHaveBeenCalledWith('task-1', workspaceId, { persistBackup: false });
-        const result = applyPreparedTaskSyncSnapshot({
-            core,
-            workspaceId,
-            prepared,
-        });
-        expect(core.applyWorkspaceSyncSnapshot).toHaveBeenCalledWith({
-            tasks: [],
-            archived: [
-                expect.objectContaining({
-                    id: 'task-2',
-                    title: 'Archived task',
-                    isArchived: true,
-                }),
-            ],
-        }, workspaceId);
-        expect(result).toEqual(expect.objectContaining({ total: 1 }));
-    });
-    it('preserves planning attachments when applying initiative and workstream sync changes', () => {
-        const core = createCoreFixture({
-            upsertInitiativeForSync: vi.fn(),
-            upsertWorkstreamForSync: vi.fn(),
-            updateTaxonomies: vi.fn(),
-        });
-        applyPlanningSyncChanges({
-            core,
-            workspaceId: 'workspace-1',
-            incomingInitiatives: new Map([
-                ['initiative-1', {
-                        id: 'initiative-1',
-                        referenceNumber: 12,
-                        referenceLabel: 'I-12',
-                        title: 'Initiative',
-                        description: 'Initiative description',
-                        ownerId: null,
-                        createdAt: '2026-04-10T09:00:00.000Z',
-                        updatedAt: '2026-04-10T10:00:00.000Z',
-                        order: 1,
-                        attachments: [{
-                                path: '/api/taskforce/documents/asset-init-doc/content',
-                                fsPath: 'workspaces/workspace-1/assets/documents/initiative.md',
-                                assetId: 'asset-init-doc',
-                                caption: 'Initiative context',
-                                timestamp: '2026-04-10T10:00:00.000Z'
-                            }],
-                        isArchived: false,
-                    }],
-            ]),
-            incomingWorkstreams: new Map([
-                ['workstream-1', {
-                        id: 'workstream-1',
-                        referenceNumber: 689,
-                        referenceLabel: 'WS-689',
-                        initiativeId: 'initiative-1',
-                        title: 'Security Audit Remediation',
-                        description: 'Workstream description',
-                        ownerId: null,
-                        createdAt: '2026-04-10T09:00:00.000Z',
-                        updatedAt: '2026-04-10T10:00:00.000Z',
-                        order: 2,
-                        attachments: [{
-                                path: '/api/taskforce/documents/asset-workstream-doc/content',
-                                fsPath: 'workspaces/workspace-1/assets/documents/security-findings-register.md',
-                                assetId: 'asset-workstream-doc',
-                                caption: 'Living security findings register for WS-689',
-                                timestamp: '2026-04-10T10:00:00.000Z'
-                            }],
-                        isArchived: false,
-                    }],
-            ]),
-            incomingTaxonomies: null,
-            incomingTaxonomyState: null,
-            incomingTaxonomiesUpdatedAt: '',
-            workspaceTaxonomySyncMeta: new Map(),
-            recordSyncDiagnostic: vi.fn(),
-        });
-        expect(core.upsertInitiativeForSync).toHaveBeenCalledWith(expect.objectContaining({
-            id: 'initiative-1',
-            attachments: [
-                expect.objectContaining({
-                    assetId: 'asset-init-doc',
-                    caption: 'Initiative context'
-                })
-            ]
-        }), 'workspace-1');
-        expect(core.upsertWorkstreamForSync).toHaveBeenCalledWith(expect.objectContaining({
-            id: 'workstream-1',
-            referenceLabel: 'WS-689',
-            attachments: [
-                expect.objectContaining({
-                    assetId: 'asset-workstream-doc',
-                    caption: 'Living security findings register for WS-689'
-                })
-            ]
-        }), 'workspace-1');
-    });
-    it('applies document and asset changes through the content handler helpers', async () => {
-        const core = createCoreFixture();
-        const writeWorkspaceSyncDocument = vi.fn().mockResolvedValue(undefined);
-        const writeWorkspaceSyncBinaryAsset = vi.fn().mockResolvedValue(undefined);
-        const deleteWorkspaceSyncDocument = vi.fn();
-        const deleteWorkspaceSyncBinaryAsset = vi.fn();
-        await applyContentSyncChanges({
-            core,
-            workspaceId: 'workspace-1',
-            incomingDocuments: [
-                {
-                    path: 'docs/spec.md',
-                    updatedAt: '2026-04-10T10:00:00.000Z',
-                    content: '# Spec',
-                    assetId: 'asset-doc-1',
-                },
-            ],
-            incomingDocumentDeletes: new Map([
-                ['docs/stale.md', '2026-04-10T11:00:00.000Z'],
-            ]),
-            incomingAssets: [
-                {
-                    path: 'assets/proof.png',
-                    updatedAt: '2026-04-10T10:05:00.000Z',
-                    contentBase64: Buffer.from('png-bytes').toString('base64'),
-                    assetId: 'asset-image-1',
-                    kind: 'image',
-                    mimeType: 'image/png',
-                },
-            ],
-            incomingAssetDeletes: new Map([
-                ['assets/stale.png', '2026-04-10T11:05:00.000Z'],
-            ]),
-            basePath: '/tmp/taskforce-sync-content',
-            hasObjectStorageClient: () => false,
-            hasDocumentSyncMetadataDrift: () => false,
-            hasBinaryAssetSyncMetadataDrift: () => false,
-            getExistingDocument: () => null,
-            writeWorkspaceSyncDocument,
-            deleteWorkspaceSyncDocument,
-            writeWorkspaceSyncBinaryAsset,
-            deleteWorkspaceSyncBinaryAsset,
-            getExistingBinaryAsset: () => null,
-            recordSyncDiagnostic: vi.fn(),
-        });
-        expect(writeWorkspaceSyncDocument).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'docs/spec.md', assetId: 'asset-doc-1' }), 'workspace-1', { allowReferenceNumberReassignment: true });
-        expect(writeWorkspaceSyncBinaryAsset).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'assets/proof.png', assetId: 'asset-image-1' }), 'workspace-1', { allowReferenceNumberReassignment: true });
-        expect(deleteWorkspaceSyncDocument).toHaveBeenCalledWith('/tmp/taskforce-sync-content', 'docs/stale.md', 'workspace-1');
-        expect(deleteWorkspaceSyncBinaryAsset).toHaveBeenCalledWith('/tmp/taskforce-sync-content', 'assets/stale.png', 'workspace-1');
-        expect(core.notifyDocumentMetadataMutation).toHaveBeenNthCalledWith(1, 'workspace-1', ['docs/spec.md', 'assets/proof.png'], 'upsert');
-        expect(core.notifyDocumentMetadataMutation).toHaveBeenNthCalledWith(2, 'workspace-1', ['docs/stale.md', 'assets/stale.png'], 'delete');
-    });
-    it('allows reference reassignment when metadata drift requires normal sync convergence', async () => {
-        const core = createCoreFixture({
-            getDocumentWatermark: vi.fn().mockReturnValue(null),
-        });
-        const writeWorkspaceSyncDocument = vi.fn().mockResolvedValue(undefined);
-        const writeWorkspaceSyncBinaryAsset = vi.fn().mockResolvedValue(undefined);
-        await applyContentSyncChanges({
-            core,
-            workspaceId: 'workspace-1',
-            incomingDocuments: [
-                {
-                    path: 'docs/spec.md',
-                    updatedAt: '2026-04-10T10:00:00.000Z',
-                    content: '# Spec',
-                    assetId: 'asset-doc-1',
-                    referenceNumber: 22,
-                },
-            ],
-            incomingDocumentDeletes: new Map(),
-            incomingAssets: [
-                {
-                    path: 'assets/proof.png',
-                    updatedAt: '2026-04-10T10:05:00.000Z',
-                    contentBase64: Buffer.from('new-bytes').toString('base64'),
-                    assetId: 'asset-image-1',
-                    kind: 'image',
-                    mimeType: 'image/png',
-                    referenceNumber: 33,
-                },
-            ],
-            incomingAssetDeletes: new Map(),
-            basePath: '/tmp/taskforce-sync-content',
-            hasObjectStorageClient: () => false,
-            hasDocumentSyncMetadataDrift: () => true,
-            hasBinaryAssetSyncMetadataDrift: () => true,
-            getExistingDocument: () => ({
-                updatedAt: '2026-04-10T10:00:00.000Z',
-                contentHash: '6bb50a17e2dc2fc14caea95a15cd8572018b6d22d74fb7b9ad015b5a0a8a935e',
-            }),
-            writeWorkspaceSyncDocument,
-            deleteWorkspaceSyncDocument: vi.fn(),
-            writeWorkspaceSyncBinaryAsset,
-            deleteWorkspaceSyncBinaryAsset: vi.fn(),
-            getExistingBinaryAsset: () => ({
-                updatedAt: '2026-04-10T10:00:00.000Z',
-                contentSha256: 'old-hash',
-            }),
-            recordSyncDiagnostic: vi.fn(),
-        });
-        expect(writeWorkspaceSyncDocument).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'docs/spec.md' }), 'workspace-1', { allowReferenceNumberReassignment: true });
-        expect(writeWorkspaceSyncBinaryAsset).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'assets/proof.png' }), 'workspace-1', { allowReferenceNumberReassignment: true });
-    });
-    it('reuses persisted content hashes instead of re-reading unchanged local files while reasserting object storage payloads', async () => {
-        const existingDocContent = '# Spec';
-        const existingAssetBytes = Buffer.from('png-bytes');
-        const core = createCoreFixture({
-            getDocumentWatermark: vi.fn().mockReturnValue({
-                updatedAt: '2026-04-10T10:00:00.000Z',
-                contentHash: createHash('sha256').update(existingDocContent).digest('hex'),
-            }),
-        });
-        const writeWorkspaceSyncDocument = vi.fn().mockResolvedValue(undefined);
-        const writeWorkspaceSyncBinaryAsset = vi.fn().mockResolvedValue(undefined);
-        const readSpy = vi.spyOn(fs, 'readFileSync').mockImplementation(((targetPath) => {
-            const value = String(targetPath);
-            if (value.endsWith('spec.md'))
-                return existingDocContent;
-            return existingAssetBytes;
-        }));
-        await applyContentSyncChanges({
-            core,
-            workspaceId: 'workspace-1',
-            incomingDocuments: [
-                {
-                    path: 'docs/spec.md',
-                    updatedAt: '2026-04-10T10:00:00.000Z',
-                    content: existingDocContent,
-                    assetId: 'asset-doc-1',
-                },
-            ],
-            incomingDocumentDeletes: new Map(),
-            incomingAssets: [
-                {
-                    path: 'assets/proof.png',
-                    updatedAt: '2026-04-10T10:05:00.000Z',
-                    contentBase64: existingAssetBytes.toString('base64'),
-                    assetId: 'asset-image-1',
-                    kind: 'image',
-                    mimeType: 'image/png',
-                },
-            ],
-            incomingAssetDeletes: new Map(),
-            basePath: '/tmp/taskforce-sync-content',
-            hasObjectStorageClient: () => true,
-            hasDocumentSyncMetadataDrift: () => false,
-            hasBinaryAssetSyncMetadataDrift: () => false,
-            getExistingDocument: () => {
-                throw new Error('document fallback should not be used when persisted metadata exists');
-            },
-            writeWorkspaceSyncDocument,
-            deleteWorkspaceSyncDocument: vi.fn(),
-            writeWorkspaceSyncBinaryAsset,
-            deleteWorkspaceSyncBinaryAsset: vi.fn(),
-            getExistingBinaryAsset: () => ({
-                updatedAt: '2026-04-10T10:05:00.000Z',
-                contentSha256: createHash('sha256').update(existingAssetBytes).digest('hex'),
-            }),
-            recordSyncDiagnostic: vi.fn(),
-        });
-        expect(readSpy).not.toHaveBeenCalled();
-        expect(writeWorkspaceSyncDocument).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'docs/spec.md', assetId: 'asset-doc-1' }), 'workspace-1', { allowReferenceNumberReassignment: false });
-        expect(writeWorkspaceSyncBinaryAsset).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'assets/proof.png', assetId: 'asset-image-1' }), 'workspace-1', { allowReferenceNumberReassignment: false });
-    });
-    it('rejects synced content applies when a binary asset write fails', async () => {
-        const core = createCoreFixture();
-        const recordSyncDiagnostic = vi.fn();
-        await expect(applyContentSyncChanges({
-            core,
-            workspaceId: 'workspace-1',
-            incomingDocuments: [],
-            incomingDocumentDeletes: new Map(),
-            incomingAssets: [
-                {
-                    path: 'assets/proof.png',
-                    updatedAt: '2026-04-10T10:05:00.000Z',
-                    contentBase64: Buffer.from('png-bytes').toString('base64'),
-                    assetId: 'asset-image-1',
-                    kind: 'image',
-                    mimeType: 'image/png',
-                },
-            ],
-            incomingAssetDeletes: new Map(),
-            basePath: '/tmp/taskforce-sync-content',
-            hasObjectStorageClient: () => true,
-            hasDocumentSyncMetadataDrift: () => false,
-            hasBinaryAssetSyncMetadataDrift: () => false,
-            getExistingDocument: () => null,
-            writeWorkspaceSyncDocument: vi.fn(),
-            deleteWorkspaceSyncDocument: vi.fn(),
-            writeWorkspaceSyncBinaryAsset: vi.fn().mockRejectedValue(new Error('R2 write failed')),
-            deleteWorkspaceSyncBinaryAsset: vi.fn(),
-            getExistingBinaryAsset: () => null,
-            recordSyncDiagnostic,
-        })).rejects.toMatchObject({
-            code: 'SYNC_CONTENT_APPLY_FAILED',
-            statusCode: 500,
-        });
-        expect(recordSyncDiagnostic).toHaveBeenCalledWith('workspace-1', 'apply', 'Failed to apply synced asset change.', expect.objectContaining({
-            source: 'assets.apply.write',
-            path: 'assets/proof.png',
-            assetId: 'asset-image-1',
-            kind: 'image',
-            error: 'R2 write failed'
-        }));
-    });
-    it('applies collaboration upserts and deletes through the collaboration handlers', () => {
-        const core = createCoreFixture();
-        applyCollaborationSyncChanges({
-            core,
-            workspaceId: 'workspace-1',
-            incomingDocumentReviewSessions: new Map([
-                ['session-1', {
-                        id: 'session-1',
-                        assetId: 'asset-doc-1',
-                        documentId: 'doc-1',
-                        documentVersion: 3,
-                        title: 'Review round',
-                        status: 'open',
-                        comments: [],
-                        createdByActorId: 'user-1',
-                        updatedByActorId: 'user-1',
-                        createdAt: '2026-04-10T09:00:00.000Z',
-                        updatedAt: '2026-04-10T10:00:00.000Z',
-                        deletedAt: null,
-                    }],
-            ]),
-            incomingDocumentReviewSessionDeletes: new Map([
-                ['session-2', '2026-04-10T11:00:00.000Z'],
-            ]),
-            incomingDocumentReviewComments: new Map([
-                ['comment-1', {
-                        id: 'comment-1',
-                        sessionId: 'session-1',
-                        body: 'Looks good',
-                        anchor: { kind: 'document' },
-                        order: 0,
-                        authorActorId: 'user-1',
-                        createdAt: '2026-04-10T09:05:00.000Z',
-                        updatedAt: '2026-04-10T10:05:00.000Z',
-                        deletedAt: null,
-                    }],
-            ]),
-            incomingDocumentReviewCommentDeletes: new Map([
-                ['comment-2', '2026-04-10T11:05:00.000Z'],
-            ]),
-            incomingAnnotatedAttachmentSessions: new Map([
-                ['annotation-session-1', {
-                        id: 'annotation-session-1',
-                        workspaceId: 'workspace-1',
-                        taskId: 'task-1',
-                        baseImageAssetId: 'asset-image-1',
-                        title: 'Annotations',
-                        globalInstruction: 'Inspect issue',
-                        annotations: [],
-                        createdByActorId: 'user-1',
-                        updatedByActorId: 'user-1',
-                        createdAt: '2026-04-10T09:10:00.000Z',
-                        updatedAt: '2026-04-10T10:10:00.000Z',
-                        deletedAt: null,
-                    }],
-            ]),
-            incomingAnnotatedAttachmentSessionDeletes: new Map([
-                ['annotation-session-2', '2026-04-10T11:10:00.000Z'],
-            ]),
-            recordSyncDiagnostic: vi.fn(),
-            createSyncRouteError: (message, details) => Object.assign(new Error(message), { details }),
-        });
-        expect(core.upsertDocumentReviewSessionForSync).toHaveBeenCalledWith(expect.objectContaining({
-            id: 'session-1',
-            workspaceId: 'workspace-1',
-            assetId: 'asset-doc-1',
-        }));
-        expect(core.deleteDocumentReviewSessionForSync).toHaveBeenCalledWith({
-            workspaceId: 'workspace-1',
-            sessionId: 'session-2',
-            deletedAt: '2026-04-10T11:00:00.000Z',
-        });
-        expect(core.upsertDocumentReviewCommentForSync).toHaveBeenCalledWith(expect.objectContaining({
-            id: 'comment-1',
-            sessionId: 'session-1',
-            workspaceId: 'workspace-1',
-        }));
-        expect(core.deleteDocumentReviewCommentForSync).toHaveBeenCalledWith({
-            workspaceId: 'workspace-1',
-            commentId: 'comment-2',
-            deletedAt: '2026-04-10T11:05:00.000Z',
-        });
-        expect(core.upsertAnnotatedAttachmentSessionForSync).toHaveBeenCalledWith(expect.objectContaining({
-            id: 'annotation-session-1',
-            workspaceId: 'workspace-1',
-            baseImageAssetId: 'asset-image-1',
-        }));
-        expect(core.deleteAnnotatedAttachmentSessionForSync).toHaveBeenCalledWith({
-            workspaceId: 'workspace-1',
-            sessionId: 'annotation-session-2',
-            deletedAt: '2026-04-10T11:10:00.000Z',
-        });
-    });
-    it('applies entity events through lean sync lookups instead of hydrated entity activity reads', () => {
-        const core = createCoreFixture({
-            taskExistsForSync: vi.fn().mockReturnValue(true),
-            getEntityEventForSync: vi.fn().mockReturnValue(null),
-            listTaskEvents: vi.fn(() => {
-                throw new Error('hydrated task activity lookup should not run during sync apply');
-            }),
-            getTask: vi.fn(() => {
-                throw new Error('hydrated task lookup should not run during sync apply');
-            }),
-            getInitiative: vi.fn(() => {
-                throw new Error('hydrated initiative lookup should not run during sync apply');
-            }),
-            getWorkstream: vi.fn(() => {
-                throw new Error('hydrated workstream lookup should not run during sync apply');
-            }),
-            listEntityEventsForSync: vi.fn(() => {
-                throw new Error('hydrated entity event listing should not run during sync apply');
-            }),
-            upsertEntityEventForSync: vi.fn(),
-        });
-        applyTaskActivitySyncChanges({
-            core,
-            workspaceId: 'workspace-1',
-            incomingTaskEvents: new Map([
-                ['task-event-1', {
-                        id: 'task-event-1',
-                        taskId: 'task-1',
-                        entityType: 'task',
-                        entityId: 'task-1',
-                        workspaceId: 'workspace-1',
-                        action: 'task-updated',
-                        actor: 'user-1',
-                        actorType: 'human',
-                        details: { changes: { status: { from: 'task', to: 'review' } } },
-                        createdAt: '2026-04-10T10:00:00.000Z',
-                    }],
-            ]),
-            recordSyncDiagnostic: vi.fn(),
-            createSyncRouteError: (message, details) => Object.assign(new Error(message), { details }),
-        });
-        expect(core.taskExistsForSync).toHaveBeenCalledWith('task-1', 'workspace-1');
-        expect(core.getEntityEventForSync).toHaveBeenCalledWith({
-            workspaceId: 'workspace-1',
-            eventId: 'task-event-1',
-        });
-        expect(core.upsertEntityEventForSync).toHaveBeenCalledWith(expect.objectContaining({
-            id: 'task-event-1',
-            taskId: 'task-1',
-            entityType: 'task',
-            entityId: 'task-1',
-            workspaceId: 'workspace-1',
-            action: 'task-updated',
-        }));
-    });
-});

package/dist/sync/syncService.test.d.ts

@@ -1 +0,0 @@
-export {};