@taskforcehq/taskforce 0.3.306 → 0.3.307

package/dist/sync/workspacePullFeed.js

@@ -5,6 +5,31 @@ export async function buildWorkspacePullFeed(input) {
     const { core, workspaceId, cursor, pageSize, encodeWorkspaceSyncCursor, contentSyncState, collaborationSyncState } = input;
     const syncCursor = cursor ? { watermark: cursor.u, id: cursor.id } : null;
     const dbFetchLimit = pageSize * 2 + 10;
+    const snapshotErrors = [];
+    const captureSnapshotError = (domain, error) => {
+        snapshotErrors.push({
+            domain,
+            error: String(error?.message || error || 'Unknown snapshot error')
+        });
+    };
+    const readSnapshot = (domain, fallback, reader) => {
+        try {
+            return reader();
+        }
+        catch (error) {
+            captureSnapshotError(domain, error);
+            return fallback;
+        }
+    };
+    const readSnapshotAsync = async (domain, fallback, reader) => {
+        try {
+            return await reader();
+        }
+        catch (error) {
+            captureSnapshotError(domain, error);
+            return fallback;
+        }
+    };
     const taskRows = core.listTasksForSync(workspaceId, syncCursor, dbFetchLimit);
     const upsertEntries = taskRows
         .map((entry) => {
@@ -28,7 +53,7 @@ export async function buildWorkspacePullFeed(input) {
         taskId: String(entry.taskId || '').trim()
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
-    const taxonomySnapshot = core.getTaxonomiesSyncSnapshot(workspaceId);
+    const taxonomySnapshot = readSnapshot('taxonomy', null, () => core.getTaxonomiesSyncSnapshot(workspaceId));
     const taxonomyEntries = (taxonomySnapshot
         && Array.isArray(taxonomySnapshot.taxonomies)
         && Number.isFinite(Date.parse(String(taxonomySnapshot.updatedAt || '').trim())))
@@ -40,7 +65,7 @@ export async function buildWorkspacePullFeed(input) {
                 ...(taxonomySnapshot.taxonomyState ? { taxonomyState: taxonomySnapshot.taxonomyState } : {})
             }]
         : [];
-    const initiativeEntries = core.listInitiatives(workspaceId)
+    const initiativeEntries = readSnapshot('initiatives', [], () => core.listInitiatives(workspaceId))
         .map((initiative) => ({
         kind: 'initiative',
         watermark: String(initiative.updatedAt || initiative.createdAt || '').trim(),
@@ -48,7 +73,7 @@ export async function buildWorkspacePullFeed(input) {
         initiative
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.initiative.id.length > 0);
-    const workstreamEntries = core.listWorkstreams(workspaceId)
+    const workstreamEntries = readSnapshot('workstreams', [], () => core.listWorkstreams(workspaceId))
         .map((workstream) => ({
         kind: 'workstream',
         watermark: String(workstream.updatedAt || workstream.createdAt || '').trim(),
@@ -56,7 +81,7 @@ export async function buildWorkspacePullFeed(input) {
         workstream
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.workstream.id.length > 0);
-    const aiProfileEntries = core.listAiProfiles(workspaceId, { includeArchived: true })
+    const aiProfileEntries = readSnapshot('ai-profiles', [], () => core.listAiProfiles(workspaceId, { includeArchived: true }))
         .map((profile) => ({
         kind: 'ai-profile',
         watermark: aiProfileSyncResourceAdapter.getWatermark(profile),
@@ -65,7 +90,7 @@ export async function buildWorkspacePullFeed(input) {
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
     const indexStartedAtMs = Date.now();
-    const documentIndex = await contentSyncState.listWorkspaceSyncDocumentIndex(core.getPaths().basePath, workspaceId);
+    const documentIndex = await readSnapshotAsync('documents.index', [], () => contentSyncState.listWorkspaceSyncDocumentIndex(core.getPaths().basePath, workspaceId));
     const documentEntries = documentIndex
         .map((doc) => ({
         kind: 'document',
@@ -77,13 +102,15 @@ export async function buildWorkspacePullFeed(input) {
         referenceNumber: doc.referenceNumber,
         version: doc.version,
         taskId: doc.taskId,
+        linkTargetType: doc.linkTargetType,
+        linkTargetId: doc.linkTargetId,
         logicalName: doc.logicalName,
         caption: doc.caption,
         originalFilename: doc.originalFilename,
         linkRole: (doc.linkRole === 'reference' ? 'reference' : 'attachment')
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
-    const documentDeleteEntries = contentSyncState.listWorkspaceSyncDocumentDeletesSnapshot(workspaceId)
+    const documentDeleteEntries = readSnapshot('documents.deletes', [], () => contentSyncState.listWorkspaceSyncDocumentDeletesSnapshot(workspaceId))
         .map((doc) => ({
         kind: 'document-delete',
         watermark: String(doc.deletedAt || '').trim(),
@@ -92,7 +119,7 @@ export async function buildWorkspacePullFeed(input) {
         assetId: typeof doc.assetId === 'string' && doc.assetId.trim().length > 0 ? doc.assetId.trim() : undefined
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
-    const documentReviewSessions = collaborationSyncState.listWorkspaceSyncDocumentReviewSessionsSnapshot(workspaceId);
+    const documentReviewSessions = readSnapshot('document-review-sessions', [], () => collaborationSyncState.listWorkspaceSyncDocumentReviewSessionsSnapshot(workspaceId));
     const documentReviewSessionEntries = documentReviewSessions
         .filter((session) => !session.deletedAt)
         .map((session) => ({
@@ -111,7 +138,7 @@ export async function buildWorkspacePullFeed(input) {
         sessionId: String(session.id || '').trim()
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sessionId.length > 0);
-    const documentReviewComments = collaborationSyncState.listWorkspaceSyncDocumentReviewCommentsSnapshot(workspaceId);
+    const documentReviewComments = readSnapshot('document-review-comments', [], () => collaborationSyncState.listWorkspaceSyncDocumentReviewCommentsSnapshot(workspaceId));
     const documentReviewCommentEntries = documentReviewComments
         .filter((comment) => !comment.deletedAt)
         .map((comment) => ({
@@ -130,7 +157,7 @@ export async function buildWorkspacePullFeed(input) {
         commentId: String(comment.id || '').trim()
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.commentId.length > 0);
-    const annotatedAttachmentSessions = collaborationSyncState.listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(workspaceId);
+    const annotatedAttachmentSessions = readSnapshot('annotated-attachment-sessions', [], () => collaborationSyncState.listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(workspaceId));
     const annotatedAttachmentSessionEntries = annotatedAttachmentSessions
         .filter((session) => !session.deletedAt)
         .map((session) => ({
@@ -149,15 +176,38 @@ export async function buildWorkspacePullFeed(input) {
         sessionId: String(session.id || '').trim()
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sessionId.length > 0);
-    const taskEventEntries = collaborationSyncState.listWorkspaceSyncTaskEventsSnapshot(workspaceId)
-        .map((event) => ({
-        kind: 'task-event',
-        watermark: String(event.createdAt || '').trim(),
-        sortId: `task-event:${String(event.id || '').trim()}`,
-        event
-    }))
-        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.event.id.length > 0 && entry.event.taskId.length > 0);
-    const assetIndex = await contentSyncState.listWorkspaceSyncBinaryAssetIndex(workspaceId);
+    const taskEventEntries = readSnapshot('task-events', [], () => collaborationSyncState.listWorkspaceSyncTaskEventsSnapshot(workspaceId))
+        .map((event) => {
+        const entityType = event.entityType === 'initiative' || event.entityType === 'workstream'
+            ? event.entityType
+            : 'task';
+        const entityId = String(event.entityId || event.taskId || '').trim();
+        if (entityType === 'task') {
+            return {
+                kind: 'task-event',
+                watermark: String(event.createdAt || '').trim(),
+                sortId: `task-event:${String(event.id || '').trim()}`,
+                event: {
+                    ...event,
+                    entityType: 'task',
+                    entityId,
+                    taskId: String(event.taskId || entityId).trim(),
+                },
+            };
+        }
+        return {
+            kind: 'entity-event',
+            watermark: String(event.createdAt || '').trim(),
+            sortId: `entity-event:${String(event.id || '').trim()}`,
+            event: {
+                ...event,
+                entityType,
+                entityId,
+            },
+        };
+    })
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.event.id.length > 0 && entry.event.entityId.length > 0 && (entry.kind !== 'task-event' || Boolean(entry.event.taskId)));
+    const assetIndex = await readSnapshotAsync('assets.index', [], () => contentSyncState.listWorkspaceSyncBinaryAssetIndex(workspaceId));
     const assetEntries = assetIndex
         .map((asset) => ({
         kind: 'asset',
@@ -169,13 +219,15 @@ export async function buildWorkspacePullFeed(input) {
         mimeType: asset.mimeType,
         referenceNumber: asset.referenceNumber,
         taskId: asset.taskId,
+        linkTargetType: asset.linkTargetType,
+        linkTargetId: asset.linkTargetId,
         logicalName: asset.logicalName,
         caption: asset.caption,
         originalFilename: asset.originalFilename,
         linkRole: asset.linkRole
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
-    const assetDeleteEntries = contentSyncState.listWorkspaceSyncBinaryAssetDeletesSnapshot(workspaceId)
+    const assetDeleteEntries = readSnapshot('assets.deletes', [], () => contentSyncState.listWorkspaceSyncBinaryAssetDeletesSnapshot(workspaceId))
         .map((asset) => ({
         kind: 'asset-delete',
         watermark: String(asset.deletedAt || '').trim(),
@@ -218,7 +270,7 @@ export async function buildWorkspacePullFeed(input) {
         return String(a.sortId || '').localeCompare(String(b.sortId || ''));
     });
     const page = afterCursor.slice(0, pageSize);
-    const workspaceMembers = core.listWorkspaceUsers(workspaceId).map((member) => ({
+    const workspaceMembers = readSnapshot('workspace-members', [], () => core.listWorkspaceUsers(workspaceId)).map((member) => ({
         userId: member.userId,
         workspaceId,
         email: member.email,
@@ -287,55 +339,61 @@ export async function buildWorkspacePullFeed(input) {
                                                 ? [{ op: 'annotated-attachment-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }]
                                                 : entry.kind === 'task-event'
                                                     ? [{ op: 'task-event-upsert', event: entry.event, watermark: entry.watermark }]
-                                                    : entry.kind === 'document'
-                                                        ? (() => {
-                                                            const payload = hydratedDocuments.get(entry.path);
-                                                            if (!payload)
-                                                                return [];
-                                                            return [{
-                                                                    op: 'document-upsert',
-                                                                    path: entry.path,
-                                                                    updatedAt: entry.watermark,
-                                                                    content: payload.content,
-                                                                    assetId: payload.assetId,
-                                                                    documentId: payload.documentId,
-                                                                    referenceNumber: payload.referenceNumber,
-                                                                    version: payload.version,
-                                                                    taskId: payload.taskId,
-                                                                    logicalName: payload.logicalName,
-                                                                    caption: payload.caption,
-                                                                    originalFilename: payload.originalFilename,
-                                                                    linkRole: payload.linkRole === 'reference' ? 'reference' : 'attachment',
-                                                                    watermark: entry.watermark
-                                                                }];
-                                                        })()
-                                                        : entry.kind === 'document-delete'
-                                                            ? [{ op: 'document-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
-                                                            : entry.kind === 'asset'
-                                                                ? (() => {
-                                                                    const payload = hydratedAssets.get(entry.path);
-                                                                    if (!payload)
-                                                                        return [];
-                                                                    return [{
-                                                                            op: 'asset-upsert',
-                                                                            path: entry.path,
-                                                                            updatedAt: entry.watermark,
-                                                                            contentBase64: payload.contentBase64,
-                                                                            assetId: payload.assetId,
-                                                                            kind: payload.kind,
-                                                                            mimeType: payload.mimeType,
-                                                                            referenceNumber: payload.referenceNumber,
-                                                                            taskId: payload.taskId,
-                                                                            logicalName: payload.logicalName,
-                                                                            caption: payload.caption,
-                                                                            originalFilename: payload.originalFilename,
-                                                                            linkRole: payload.linkRole,
-                                                                            watermark: entry.watermark
-                                                                        }];
-                                                                })()
-                                                                : entry.kind === 'asset-delete'
-                                                                    ? [{ op: 'asset-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
-                                                                    : [{ op: 'upsert', task: entry.task, archived: Boolean(entry.archived), watermark: entry.watermark }]));
+                                                    : entry.kind === 'entity-event'
+                                                        ? [{ op: 'entity-event-upsert', event: entry.event, watermark: entry.watermark }]
+                                                        : entry.kind === 'document'
+                                                            ? (() => {
+                                                                const payload = hydratedDocuments.get(entry.path);
+                                                                if (!payload)
+                                                                    return [];
+                                                                return [{
+                                                                        op: 'document-upsert',
+                                                                        path: entry.path,
+                                                                        updatedAt: entry.watermark,
+                                                                        content: payload.content,
+                                                                        assetId: payload.assetId,
+                                                                        documentId: payload.documentId,
+                                                                        referenceNumber: payload.referenceNumber,
+                                                                        version: payload.version,
+                                                                        taskId: payload.taskId,
+                                                                        linkTargetType: payload.linkTargetType,
+                                                                        linkTargetId: payload.linkTargetId,
+                                                                        logicalName: payload.logicalName,
+                                                                        caption: payload.caption,
+                                                                        originalFilename: payload.originalFilename,
+                                                                        linkRole: payload.linkRole === 'reference' ? 'reference' : 'attachment',
+                                                                        watermark: entry.watermark
+                                                                    }];
+                                                            })()
+                                                            : entry.kind === 'document-delete'
+                                                                ? [{ op: 'document-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                                                : entry.kind === 'asset'
+                                                                    ? (() => {
+                                                                        const payload = hydratedAssets.get(entry.path);
+                                                                        if (!payload)
+                                                                            return [];
+                                                                        return [{
+                                                                                op: 'asset-upsert',
+                                                                                path: entry.path,
+                                                                                updatedAt: entry.watermark,
+                                                                                contentBase64: payload.contentBase64,
+                                                                                assetId: payload.assetId,
+                                                                                kind: payload.kind,
+                                                                                mimeType: payload.mimeType,
+                                                                                referenceNumber: payload.referenceNumber,
+                                                                                taskId: payload.taskId,
+                                                                                linkTargetType: payload.linkTargetType,
+                                                                                linkTargetId: payload.linkTargetId,
+                                                                                logicalName: payload.logicalName,
+                                                                                caption: payload.caption,
+                                                                                originalFilename: payload.originalFilename,
+                                                                                linkRole: payload.linkRole,
+                                                                                watermark: entry.watermark
+                                                                            }];
+                                                                    })()
+                                                                    : entry.kind === 'asset-delete'
+                                                                        ? [{ op: 'asset-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                                                        : [{ op: 'upsert', task: entry.task, archived: Boolean(entry.archived), watermark: entry.watermark }]));
     const encodeMs = Date.now() - encodeStartedAtMs;
     return {
         workspaceMembers,
@@ -351,7 +409,8 @@ export async function buildWorkspacePullFeed(input) {
             indexMs,
             hydrationMs,
             encodeMs,
-            buildMs: Date.now() - buildStartedAtMs
+            buildMs: Date.now() - buildStartedAtMs,
+            snapshotErrors
         }
     };
 }

package/dist/sync/workspacePullFeed.test.js

@@ -211,6 +211,55 @@ describe('workspacePullFeed', () => {
         expect(result.nextCursor).toBe('2026-04-10T10:05:00.000Z|ai-profile:ai-profile-1');
         expect(result.hasMore).toBe(false);
     });
+    it('degrades optional snapshot failures into diagnostics instead of throwing the pull feed', async () => {
+        const core = createCoreMock();
+        const content = createContentSyncStateMock();
+        const collaboration = createCollaborationSyncStateMock();
+        core.listTasksForSync = () => [
+            {
+                archived: false,
+                task: {
+                    id: 'task-1',
+                    title: 'Still syncs tasks',
+                    status: 'task',
+                    category: 'general',
+                    type: 'task',
+                    createdAt: '2026-04-10T10:00:00.000Z',
+                }
+            }
+        ];
+        core.listWorkspaceUsers = () => {
+            throw new Error('workspace members exploded');
+        };
+        content.listWorkspaceSyncBinaryAssetIndex = async () => {
+            throw new Error('asset index exploded');
+        };
+        collaboration.listWorkspaceSyncDocumentReviewSessionsSnapshot = () => {
+            throw new Error('review sessions exploded');
+        };
+        const result = await buildWorkspacePullFeed({
+            core,
+            workspaceId: 'workspace-1',
+            cursor: null,
+            pageSize: 10,
+            encodeWorkspaceSyncCursor: encodeCursor,
+            contentSyncState: content,
+            collaborationSyncState: collaboration,
+        });
+        expect(result.changes).toEqual([
+            expect.objectContaining({
+                op: 'upsert',
+                task: expect.objectContaining({ id: 'task-1' })
+            })
+        ]);
+        expect(result.workspaceMembers).toEqual([]);
+        expect(result.diagnostics.assetIndexCount).toBe(0);
+        expect(result.diagnostics.snapshotErrors).toEqual(expect.arrayContaining([
+            expect.objectContaining({ domain: 'assets.index', error: 'asset index exploded' }),
+            expect.objectContaining({ domain: 'document-review-sessions', error: 'review sessions exploded' }),
+            expect.objectContaining({ domain: 'workspace-members', error: 'workspace members exploded' }),
+        ]));
+    });
     it('hydrates document and asset payloads only for entries included in the current page', async () => {
         const core = createCoreMock();
         const content = createContentSyncStateMock();

package/dist/sync/workspaceSyncModel.d.ts

@@ -1,4 +1,4 @@
-import type { InitiativeItem, TaskEvent, TaskItem, WorkstreamItem } from '../types';
+import type { AttachmentItem, EntityEvent, InitiativeItem, TaskItem, WorkstreamItem } from '../types';
 import type { DocumentReviewCommentRecord, DocumentReviewSessionStatus } from '../documentReviews/types.js';
 import type { AnnotatedAttachmentAnnotation } from '../annotatedAttachments/types.js';
 import type { WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
@@ -6,16 +6,23 @@ import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
 import { type AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 import { type TaskSyncPayload } from './taskSyncPayload.js';
 export type WorkspaceSyncTaskSnapshot = TaskSyncPayload;
-export interface WorkspaceSyncTaskEventSnapshot {
+export interface WorkspaceSyncEntityEventSnapshot {
     id: string;
-    taskId: string;
     workspaceId: string;
+    entityType: 'task' | 'initiative' | 'workstream';
+    entityId: string;
+    taskId?: string;
     action: string;
     actor: string;
     actorType: 'system' | 'human' | 'ai';
-    details?: TaskEvent['details'];
+    details?: EntityEvent['details'];
     createdAt: string;
 }
+export type WorkspaceSyncTaskEventSnapshot = WorkspaceSyncEntityEventSnapshot & {
+    entityType: 'task';
+    entityId: string;
+    taskId: string;
+};
 export interface WorkspaceSyncAiProfileSnapshot {
     id: string;
     workspaceId: string;
@@ -26,6 +33,8 @@ export interface WorkspaceSyncAiProfileSnapshot {
     color: string;
     avatarUrl?: string | null;
     avatarSourceUrl?: string | null;
+    avatarRevision?: number;
+    avatarUpdatedAt?: string | null;
     description?: string | null;
     role?: string | null;
     provider?: string | null;
@@ -105,6 +114,7 @@ export interface WorkspaceSyncInitiativeSnapshot {
     createdAt: string;
     updatedAt?: string;
     order?: number | null;
+    attachments?: Array<string | AttachmentItem>;
     isArchived?: boolean;
 }
 export interface WorkspaceSyncWorkstreamSnapshot {
@@ -118,6 +128,7 @@ export interface WorkspaceSyncWorkstreamSnapshot {
     createdAt: string;
     updatedAt?: string;
     order?: number | null;
+    attachments?: Array<string | AttachmentItem>;
     isArchived?: boolean;
 }
 export type WorkspaceSyncChange = {
@@ -153,6 +164,8 @@ export type WorkspaceSyncChange = {
     referenceNumber?: number | null;
     version?: number | null;
     taskId?: string | null;
+    linkTargetType?: 'task' | 'initiative' | 'workstream' | null;
+    linkTargetId?: string | null;
     logicalName?: string | null;
     caption?: string | null;
     originalFilename?: string | null;
@@ -172,6 +185,8 @@ export type WorkspaceSyncChange = {
     mimeType: string;
     referenceNumber?: number | null;
     taskId?: string | null;
+    linkTargetType?: 'task' | 'initiative' | 'workstream' | null;
+    linkTargetId?: string | null;
     logicalName?: string | null;
     caption?: string | null;
     originalFilename?: string | null;
@@ -202,6 +217,9 @@ export type WorkspaceSyncChange = {
     op: 'annotated-attachment-session-delete';
     sessionId: string;
     deletedAt?: string;
+} | {
+    op: 'entity-event-upsert';
+    event: WorkspaceSyncEntityEventSnapshot;
 } | {
     op: 'task-event-upsert';
     event: WorkspaceSyncTaskEventSnapshot;
@@ -276,6 +294,8 @@ export interface WorkspaceSyncDocumentSnapshot {
     referenceNumber?: number | null;
     version?: number | null;
     taskId?: string | null;
+    linkTargetType?: 'task' | 'initiative' | 'workstream' | null;
+    linkTargetId?: string | null;
     logicalName?: string | null;
     caption?: string | null;
     originalFilename?: string | null;
@@ -290,6 +310,8 @@ export interface WorkspaceSyncAssetSnapshot {
     mimeType: string;
     referenceNumber?: number | null;
     taskId?: string | null;
+    linkTargetType?: 'task' | 'initiative' | 'workstream' | null;
+    linkTargetId?: string | null;
     logicalName?: string | null;
     caption?: string | null;
     originalFilename?: string | null;
@@ -313,7 +335,7 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     documentReviewSessions?: WorkspaceSyncDocumentReviewSessionSnapshot[];
     documentReviewComments?: WorkspaceSyncDocumentReviewCommentSnapshot[];
     annotatedAttachmentSessions?: WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
-    taskEvents?: WorkspaceSyncTaskEventSnapshot[];
+    taskEvents?: WorkspaceSyncEntityEventSnapshot[];
     lastPushedInitiativeIds?: Set<string>;
     lastPushedInitiativeWatermarks?: Map<string, string>;
     lastPushedWorkstreamIds?: Set<string>;
@@ -357,5 +379,5 @@ export declare function buildWorkspaceSyncSignatureModel(input: {
     documentReviewSessions?: WorkspaceSyncDocumentReviewSessionSnapshot[];
     documentReviewComments?: WorkspaceSyncDocumentReviewCommentSnapshot[];
     annotatedAttachmentSessions?: WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
-    taskEvents?: WorkspaceSyncTaskEventSnapshot[];
+    taskEvents?: WorkspaceSyncEntityEventSnapshot[];
 }): string;