@taskforcehq/taskforce 0.3.302 → 0.3.304

package/dist/sync/workspacePullFeed.js

@@ -1,5 +1,6 @@
 import { serializeTaskForSync } from './taskSyncPayload.js';
 export async function buildWorkspacePullFeed(input) {
+    const buildStartedAtMs = Date.now();
     const { core, workspaceId, cursor, pageSize, encodeWorkspaceSyncCursor, contentSyncState, collaborationSyncState } = input;
     const syncCursor = cursor ? { watermark: cursor.u, id: cursor.id } : null;
     const dbFetchLimit = pageSize * 2 + 10;
@@ -62,13 +63,14 @@ export async function buildWorkspacePullFeed(input) {
         profile
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
-    const documentEntries = (await contentSyncState.listWorkspaceSyncDocumentsSnapshot(core.getPaths().basePath, workspaceId))
+    const indexStartedAtMs = Date.now();
+    const documentIndex = await contentSyncState.listWorkspaceSyncDocumentIndex(core.getPaths().basePath, workspaceId);
+    const documentEntries = documentIndex
         .map((doc) => ({
         kind: 'document',
         watermark: String(doc.updatedAt || '').trim(),
         sortId: `doc:${String(doc.path || '').trim()}`,
         path: String(doc.path || '').trim(),
-        content: String(doc.content || ''),
         assetId: doc.assetId,
         documentId: doc.documentId,
         referenceNumber: doc.referenceNumber,
@@ -146,13 +148,21 @@ export async function buildWorkspacePullFeed(input) {
         sessionId: String(session.id || '').trim()
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sessionId.length > 0);
-    const assetEntries = (await contentSyncState.listWorkspaceSyncBinaryAssetsSnapshot(core.getPaths().basePath, workspaceId))
+    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 assetEntries = assetIndex
         .map((asset) => ({
         kind: 'asset',
         watermark: String(asset.updatedAt || '').trim(),
         sortId: `asset:${String(asset.path || '').trim()}`,
         path: String(asset.path || '').trim(),
-        contentBase64: String(asset.contentBase64 || ''),
         assetId: asset.assetId,
         kindValue: asset.kind,
         mimeType: asset.mimeType,
@@ -163,7 +173,7 @@ export async function buildWorkspacePullFeed(input) {
         originalFilename: asset.originalFilename,
         linkRole: asset.linkRole
     }))
-        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0 && entry.contentBase64.length > 0);
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
     const assetDeleteEntries = contentSyncState.listWorkspaceSyncBinaryAssetDeletesSnapshot(workspaceId)
         .map((asset) => ({
         kind: 'asset-delete',
@@ -188,6 +198,7 @@ export async function buildWorkspacePullFeed(input) {
         ...documentReviewCommentDeleteEntries,
         ...annotatedAttachmentSessionEntries,
         ...annotatedAttachmentSessionDeleteEntries,
+        ...taskEventEntries,
         ...assetEntries,
         ...assetDeleteEntries
     ];
@@ -206,11 +217,6 @@ export async function buildWorkspacePullFeed(input) {
         return String(a.sortId || '').localeCompare(String(b.sortId || ''));
     });
     const page = afterCursor.slice(0, pageSize);
-    const hasMore = afterCursor.length > pageSize;
-    const last = page.length > 0 ? page[page.length - 1] : null;
-    const nextCursor = encodeWorkspaceSyncCursor(last
-        ? { u: last.watermark, id: String(last.sortId || '') }
-        : cursor);
     const workspaceMembers = core.listWorkspaceUsers(workspaceId).map((member) => ({
         userId: member.userId,
         workspaceId,
@@ -225,77 +231,126 @@ export async function buildWorkspacePullFeed(input) {
         updatedAt: member.updatedAt || null,
         emailVerifiedAt: member.emailVerifiedAt || null
     }));
-    const changes = page.map((entry) => (entry.kind === 'delete'
-        ? { op: 'delete', taskId: entry.taskId, deletedAt: entry.watermark, watermark: entry.watermark }
+    const indexMs = Date.now() - indexStartedAtMs;
+    const hydratedDocuments = new Map();
+    const hydratedAssets = new Map();
+    const hydrationStartedAtMs = Date.now();
+    await Promise.all(page.map(async (entry) => {
+        if (entry.kind === 'document') {
+            const payload = await contentSyncState.loadWorkspaceSyncDocumentPayload(core.getPaths().basePath, workspaceId, entry.path);
+            hydratedDocuments.set(entry.path, payload);
+            return;
+        }
+        if (entry.kind === 'asset') {
+            const payload = await contentSyncState.loadWorkspaceSyncBinaryAssetPayload(core.getPaths().basePath, workspaceId, entry.path);
+            hydratedAssets.set(entry.path, payload);
+        }
+    }));
+    const hydrationMs = Date.now() - hydrationStartedAtMs;
+    const skippedHydrationEntries = page.filter((entry) => ((entry.kind === 'document' && !hydratedDocuments.get(entry.path))
+        || (entry.kind === 'asset' && !hydratedAssets.get(entry.path)))).length;
+    const effectivePage = page;
+    const hasMore = afterCursor.length > page.length;
+    const last = page.length > 0 ? page[page.length - 1] : null;
+    const nextCursor = encodeWorkspaceSyncCursor(last
+        ? { u: last.watermark, id: String(last.sortId || '') }
+        : cursor);
+    const encodeStartedAtMs = Date.now();
+    const changes = effectivePage.flatMap((entry) => (entry.kind === 'delete'
+        ? [{ op: 'delete', taskId: entry.taskId, watermark: entry.watermark }]
         : entry.kind === 'taxonomy'
-            ? {
-                op: 'taxonomy-upsert',
-                taxonomies: entry.taxonomies,
-                ...(entry.taxonomyState ? { taxonomyState: entry.taxonomyState } : {}),
-                updatedAt: entry.watermark,
-                watermark: entry.watermark
-            }
+            ? [{
+                    op: 'taxonomy-upsert',
+                    taxonomies: entry.taxonomies,
+                    ...(entry.taxonomyState ? { taxonomyState: entry.taxonomyState } : {}),
+                    updatedAt: entry.watermark,
+                    watermark: entry.watermark
+                }]
             : entry.kind === 'initiative'
-                ? { op: 'initiative-upsert', initiative: entry.initiative, updatedAt: entry.watermark, watermark: entry.watermark }
+                ? [{ op: 'initiative-upsert', initiative: entry.initiative, watermark: entry.watermark }]
                 : entry.kind === 'workstream'
-                    ? { op: 'workstream-upsert', workstream: entry.workstream, updatedAt: entry.watermark, watermark: entry.watermark }
+                    ? [{ op: 'workstream-upsert', workstream: entry.workstream, watermark: entry.watermark }]
                     : entry.kind === 'ai-profile'
-                        ? { op: 'ai-profile-upsert', profile: entry.profile, updatedAt: entry.watermark, watermark: entry.watermark }
+                        ? [{ op: 'ai-profile-upsert', profile: entry.profile, watermark: entry.watermark }]
                         : entry.kind === 'document-review-session'
-                            ? { op: 'document-review-session-upsert', session: entry.session, updatedAt: entry.watermark, watermark: entry.watermark }
+                            ? [{ op: 'document-review-session-upsert', session: entry.session, watermark: entry.watermark }]
                             : entry.kind === 'document-review-session-delete'
-                                ? { op: 'document-review-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }
+                                ? [{ op: 'document-review-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }]
                                 : entry.kind === 'document-review-comment'
-                                    ? { op: 'document-review-comment-upsert', comment: entry.comment, updatedAt: entry.watermark, watermark: entry.watermark }
+                                    ? [{ op: 'document-review-comment-upsert', comment: entry.comment, watermark: entry.watermark }]
                                     : entry.kind === 'document-review-comment-delete'
-                                        ? { op: 'document-review-comment-delete', commentId: entry.commentId, deletedAt: entry.watermark, watermark: entry.watermark }
+                                        ? [{ op: 'document-review-comment-delete', commentId: entry.commentId, deletedAt: entry.watermark, watermark: entry.watermark }]
                                         : entry.kind === 'annotated-attachment-session'
-                                            ? { op: 'annotated-attachment-session-upsert', session: entry.session, updatedAt: entry.watermark, watermark: entry.watermark }
+                                            ? [{ op: 'annotated-attachment-session-upsert', session: entry.session, watermark: entry.watermark }]
                                             : entry.kind === 'annotated-attachment-session-delete'
-                                                ? { op: 'annotated-attachment-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }
-                                                : entry.kind === 'document'
-                                                    ? {
-                                                        op: 'document-upsert',
-                                                        path: entry.path,
-                                                        updatedAt: entry.watermark,
-                                                        content: entry.content,
-                                                        assetId: entry.assetId,
-                                                        documentId: entry.documentId,
-                                                        referenceNumber: entry.referenceNumber,
-                                                        version: entry.version,
-                                                        taskId: entry.taskId,
-                                                        logicalName: entry.logicalName,
-                                                        caption: entry.caption,
-                                                        originalFilename: entry.originalFilename,
-                                                        linkRole: entry.linkRole,
-                                                        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'
-                                                            ? {
-                                                                op: 'asset-upsert',
-                                                                path: entry.path,
-                                                                updatedAt: entry.watermark,
-                                                                contentBase64: entry.contentBase64,
-                                                                assetId: entry.assetId,
-                                                                kind: entry.kindValue,
-                                                                mimeType: entry.mimeType,
-                                                                referenceNumber: entry.referenceNumber,
-                                                                taskId: entry.taskId,
-                                                                logicalName: entry.logicalName,
-                                                                caption: entry.caption,
-                                                                originalFilename: entry.originalFilename,
-                                                                linkRole: entry.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 }));
+                                                ? [{ 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 }]));
+    const encodeMs = Date.now() - encodeStartedAtMs;
     return {
         workspaceMembers,
         changes,
         nextCursor,
-        hasMore
+        hasMore,
+        diagnostics: {
+            totalEntries: all.length,
+            pageEntries: page.length,
+            skippedHydrationEntries,
+            documentIndexCount: documentIndex.length,
+            assetIndexCount: assetIndex.length,
+            indexMs,
+            hydrationMs,
+            encodeMs,
+            buildMs: Date.now() - buildStartedAtMs
+        }
     };
 }

package/dist/sync/workspacePullFeed.test.js

@@ -14,9 +14,13 @@ function createCoreMock() {
 }
 function createContentSyncStateMock() {
     return {
+        listWorkspaceSyncDocumentIndex: async () => [],
         listWorkspaceSyncDocumentsSnapshot: async () => [],
+        loadWorkspaceSyncDocumentPayload: async () => null,
         listWorkspaceSyncDocumentDeletesSnapshot: () => [],
+        listWorkspaceSyncBinaryAssetIndex: async () => [],
         listWorkspaceSyncBinaryAssetsSnapshot: async () => [],
+        loadWorkspaceSyncBinaryAssetPayload: async () => null,
         listWorkspaceSyncBinaryAssetDeletesSnapshot: () => [],
     };
 }
@@ -25,6 +29,7 @@ function createCollaborationSyncStateMock() {
         listWorkspaceSyncDocumentReviewSessionsSnapshot: () => [],
         listWorkspaceSyncDocumentReviewCommentsSnapshot: () => [],
         listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: () => [],
+        listWorkspaceSyncTaskEventsSnapshot: () => [],
     };
 }
 function encodeCursor(cursor) {
@@ -163,4 +168,179 @@ describe('workspacePullFeed', () => {
             })
         ]);
     });
+    it('hydrates document and asset payloads only for entries included in the current page', async () => {
+        const core = createCoreMock();
+        const content = createContentSyncStateMock();
+        const loadedDocs = [];
+        const loadedAssets = [];
+        content.listWorkspaceSyncDocumentIndex = async () => [
+            {
+                path: 'docs/a.md',
+                updatedAt: '2026-04-10T10:00:00.000Z',
+                assetId: 'asset-doc-a',
+            },
+            {
+                path: 'docs/z.md',
+                updatedAt: '2026-04-12T10:00:00.000Z',
+                assetId: 'asset-doc-z',
+            }
+        ];
+        content.loadWorkspaceSyncDocumentPayload = async (_basePath, _workspaceId, relativePath) => {
+            loadedDocs.push(relativePath);
+            return {
+                path: relativePath,
+                updatedAt: relativePath === 'docs/a.md' ? '2026-04-10T10:00:00.000Z' : '2026-04-12T10:00:00.000Z',
+                content: `content:${relativePath}`
+            };
+        };
+        content.listWorkspaceSyncBinaryAssetIndex = async () => [
+            {
+                path: 'workspaces/ws/assets/images/a.png',
+                updatedAt: '2026-04-11T10:00:00.000Z',
+                assetId: 'asset-image-a',
+                kind: 'image',
+                mimeType: 'image/png'
+            }
+        ];
+        content.loadWorkspaceSyncBinaryAssetPayload = async (_basePath, _workspaceId, assetPath) => {
+            loadedAssets.push(assetPath);
+            return {
+                path: assetPath,
+                updatedAt: '2026-04-11T10:00:00.000Z',
+                contentBase64: 'Zm9v',
+                kind: 'image',
+                mimeType: 'image/png'
+            };
+        };
+        const result = await buildWorkspacePullFeed({
+            core,
+            workspaceId: 'workspace-3',
+            cursor: null,
+            pageSize: 2,
+            encodeWorkspaceSyncCursor: encodeCursor,
+            contentSyncState: content,
+            collaborationSyncState: createCollaborationSyncStateMock(),
+        });
+        expect(result.changes).toHaveLength(2);
+        expect(result.changes[0]).toEqual(expect.objectContaining({
+            op: 'document-upsert',
+            path: 'docs/a.md',
+            content: 'content:docs/a.md'
+        }));
+        expect(result.changes[1]).toEqual(expect.objectContaining({
+            op: 'asset-upsert',
+            path: 'workspaces/ws/assets/images/a.png',
+            contentBase64: 'Zm9v'
+        }));
+        expect(loadedDocs).toEqual(['docs/a.md']);
+        expect(loadedAssets).toEqual(['workspaces/ws/assets/images/a.png']);
+    });
+    it('skips hydration misses without blocking later feed progress', async () => {
+        const core = createCoreMock();
+        const content = createContentSyncStateMock();
+        core.listTasksForSync = () => [
+            {
+                archived: false,
+                task: {
+                    id: 'task-after-miss',
+                    title: 'Task after miss',
+                    status: 'task',
+                    category: 'general',
+                    type: 'task',
+                    createdAt: '2026-04-12T10:00:00.000Z',
+                }
+            }
+        ];
+        content.listWorkspaceSyncDocumentIndex = async () => [
+            {
+                path: 'docs/a.md',
+                updatedAt: '2026-04-10T10:00:00.000Z',
+                assetId: 'asset-doc-a',
+            },
+            {
+                path: 'docs/b.md',
+                updatedAt: '2026-04-11T10:00:00.000Z',
+                assetId: 'asset-doc-b',
+            }
+        ];
+        content.loadWorkspaceSyncDocumentPayload = async (_basePath, _workspaceId, relativePath) => (relativePath === 'docs/a.md'
+            ? {
+                path: relativePath,
+                updatedAt: '2026-04-10T10:00:00.000Z',
+                content: 'content:docs/a.md'
+            }
+            : null);
+        const result = await buildWorkspacePullFeed({
+            core,
+            workspaceId: 'workspace-4',
+            cursor: null,
+            pageSize: 3,
+            encodeWorkspaceSyncCursor: encodeCursor,
+            contentSyncState: content,
+            collaborationSyncState: createCollaborationSyncStateMock(),
+        });
+        expect(result.changes).toEqual([
+            expect.objectContaining({
+                op: 'document-upsert',
+                path: 'docs/a.md',
+                content: 'content:docs/a.md'
+            }),
+            expect.objectContaining({
+                op: 'upsert',
+                task: expect.objectContaining({
+                    id: 'task-after-miss'
+                })
+            })
+        ]);
+        expect(result.nextCursor).toBe('2026-04-12T10:00:00.000Z|task-after-miss');
+        expect(result.hasMore).toBe(false);
+        expect(result.diagnostics.skippedHydrationEntries).toBe(1);
+    });
+    it('includes task-event upserts in the pull feed ordered by event watermark', async () => {
+        const core = createCoreMock();
+        const collaboration = createCollaborationSyncStateMock();
+        collaboration.listWorkspaceSyncTaskEventsSnapshot = () => [
+            {
+                id: 'task-event-2',
+                taskId: 'task-2',
+                workspaceId: 'workspace-5',
+                action: 'task-archived',
+                actor: 'ai-profile-2',
+                actorType: 'ai',
+                createdAt: '2026-04-12T10:06:00.000Z',
+                details: {}
+            },
+            {
+                id: 'task-event-1',
+                taskId: 'task-1',
+                workspaceId: 'workspace-5',
+                action: 'task-status-changed',
+                actor: 'ai-profile-1',
+                actorType: 'ai',
+                createdAt: '2026-04-12T10:05:00.000Z',
+                details: {}
+            }
+        ];
+        const result = await buildWorkspacePullFeed({
+            core,
+            workspaceId: 'workspace-5',
+            cursor: null,
+            pageSize: 5,
+            encodeWorkspaceSyncCursor: encodeCursor,
+            contentSyncState: createContentSyncStateMock(),
+            collaborationSyncState: collaboration,
+        });
+        expect(result.changes).toEqual([
+            expect.objectContaining({
+                op: 'task-event-upsert',
+                watermark: '2026-04-12T10:05:00.000Z',
+                event: expect.objectContaining({ id: 'task-event-1' })
+            }),
+            expect.objectContaining({
+                op: 'task-event-upsert',
+                watermark: '2026-04-12T10:06:00.000Z',
+                event: expect.objectContaining({ id: 'task-event-2' })
+            })
+        ]);
+    });
 });

package/dist/sync/workspaceSyncModel.d.ts

@@ -1,10 +1,20 @@
-import type { InitiativeItem, TaskItem, WorkstreamItem } from '../types';
+import type { InitiativeItem, TaskEvent, 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';
 import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
 import { type TaskSyncPayload } from './taskSyncPayload.js';
 export type WorkspaceSyncTaskSnapshot = TaskSyncPayload;
+export interface WorkspaceSyncTaskEventSnapshot {
+    id: string;
+    taskId: string;
+    workspaceId: string;
+    action: string;
+    actor: string;
+    actorType: 'system' | 'human' | 'ai';
+    details?: TaskEvent['details'];
+    createdAt: string;
+}
 export interface WorkspaceSyncAiProfileSnapshot {
     id: string;
     workspaceId: string;
@@ -13,6 +23,10 @@ export interface WorkspaceSyncAiProfileSnapshot {
     username: string;
     icon: string;
     color: string;
+    description?: string | null;
+    role?: string | null;
+    provider?: string | null;
+    model?: string | null;
     surfaceType?: AiProfileSurfaceType | null;
     providerMetadata?: Record<string, unknown> | null;
     createdAt: string;
@@ -177,6 +191,9 @@ export type WorkspaceSyncChange = {
     op: 'annotated-attachment-session-delete';
     sessionId: string;
     deletedAt?: string;
+} | {
+    op: 'task-event-upsert';
+    event: WorkspaceSyncTaskEventSnapshot;
 };
 export interface WorkspaceSyncPayload {
     changes: WorkspaceSyncChange[];
@@ -203,6 +220,7 @@ export interface WorkspaceSyncPayload {
     currentAnnotatedAttachmentSessionIds: Set<string>;
     deleteAnnotatedAttachmentSessionIds: Set<string>;
     currentAnnotatedAttachmentSessionWatermarks: Map<string, string>;
+    currentTaskEventWatermarks: Map<string, string>;
     /** Watermarks for every task upsert included in this payload (id → updatedAt|createdAt). */
     pushedWatermarks: Map<string, string>;
 }
@@ -250,6 +268,7 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     documentReviewSessions?: WorkspaceSyncDocumentReviewSessionSnapshot[];
     documentReviewComments?: WorkspaceSyncDocumentReviewCommentSnapshot[];
     annotatedAttachmentSessions?: WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
+    taskEvents?: WorkspaceSyncTaskEventSnapshot[];
     lastPushedInitiativeIds?: Set<string>;
     lastPushedInitiativeWatermarks?: Map<string, string>;
     lastPushedWorkstreamIds?: Set<string>;
@@ -266,6 +285,7 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     lastPushedDocumentReviewCommentWatermarks?: Map<string, string>;
     lastPushedAnnotatedAttachmentSessionIds?: Set<string>;
     lastPushedAnnotatedAttachmentSessionWatermarks?: Map<string, string>;
+    lastPushedTaskEventWatermarks?: Map<string, string>;
     /**
      * Watermark (updatedAt|createdAt) of each task as of its last successful push.
      * When provided, only tasks whose watermark differs from this map are included
@@ -289,4 +309,5 @@ export declare function buildWorkspaceSyncSignatureModel(input: {
     documentReviewSessions?: WorkspaceSyncDocumentReviewSessionSnapshot[];
     documentReviewComments?: WorkspaceSyncDocumentReviewCommentSnapshot[];
     annotatedAttachmentSessions?: WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
+    taskEvents?: WorkspaceSyncTaskEventSnapshot[];
 }): string;

package/dist/sync/workspaceSyncModel.js

@@ -3,6 +3,16 @@ import { serializeTaskForSync } from './taskSyncPayload.js';
 export function toWorkspaceSyncTaskSnapshot(task) {
     return serializeTaskForSync(task);
 }
+function sortTaskEventsForSync(taskEvents) {
+    return [...taskEvents].sort((left, right) => {
+        const leftCreatedAt = String(left?.createdAt || '').trim();
+        const rightCreatedAt = String(right?.createdAt || '').trim();
+        const watermarkDelta = leftCreatedAt.localeCompare(rightCreatedAt);
+        if (watermarkDelta !== 0)
+            return watermarkDelta;
+        return String(left?.id || '').trim().localeCompare(String(right?.id || '').trim());
+    });
+}
 function sortTasksForSync(tasks) {
     return [...tasks].sort((left, right) => {
         const leftId = String(left?.id || '').trim();
@@ -175,6 +185,10 @@ export function buildWorkspaceSyncPayloadModel(input) {
             username: String(profile.username || '').trim(),
             icon: String(profile.icon || 'Bot').trim() || 'Bot',
             color: String(profile.color || '#8b5cf6').trim() || '#8b5cf6',
+            description: typeof profile.description === 'string' ? profile.description.trim() || null : null,
+            role: typeof profile.role === 'string' ? profile.role.trim() || null : null,
+            provider: typeof profile.provider === 'string' ? profile.provider.trim() || null : null,
+            model: typeof profile.model === 'string' ? profile.model.trim() || null : null,
             surfaceType: parseAiProfileSurfaceType(profile.surfaceType),
             providerMetadata: profile.providerMetadata && typeof profile.providerMetadata === 'object' && !Array.isArray(profile.providerMetadata)
                 ? profile.providerMetadata
@@ -391,6 +405,40 @@ export function buildWorkspaceSyncPayloadModel(input) {
             return true;
         return previousAnnotatedAttachmentSessionWatermarks.get(change.session.id) !== change.session.updatedAt;
     });
+    const taskEvents = sortTaskEventsForSync(Array.isArray(input.taskEvents) ? input.taskEvents : []);
+    const currentTaskEventWatermarks = new Map(taskEvents
+        .map((event) => [String(event?.id || '').trim(), String(event?.createdAt || '').trim()])
+        .filter(([id]) => id.length > 0));
+    const previousTaskEventWatermarks = input.lastPushedTaskEventWatermarks;
+    const shouldSendAllTaskEvents = !previousTaskEventWatermarks || previousTaskEventWatermarks.size === 0;
+    const taskEventUpsertChanges = taskEvents
+        .map((event) => ({
+        op: 'task-event-upsert',
+        event: {
+            id: String(event.id || '').trim(),
+            taskId: String(event.taskId || '').trim(),
+            workspaceId: String(event.workspaceId || '').trim(),
+            action: String(event.action || '').trim(),
+            actor: String(event.actor || 'system').trim() || 'system',
+            actorType: event.actorType === 'ai' || event.actorType === 'human' || event.actorType === 'system'
+                ? event.actorType
+                : 'system',
+            details: event.details && typeof event.details === 'object' && !Array.isArray(event.details)
+                ? event.details
+                : {},
+            createdAt: String(event.createdAt || '').trim(),
+        }
+    }))
+        .filter((change) => (change.event.id.length > 0
+        && change.event.taskId.length > 0
+        && change.event.workspaceId.length > 0
+        && change.event.action.length > 0
+        && Number.isFinite(Date.parse(change.event.createdAt))))
+        .filter((change) => {
+        if (shouldSendAllTaskEvents)
+            return true;
+        return previousTaskEventWatermarks.get(change.event.id) !== change.event.createdAt;
+    });
     const changes = [
         ...initiativeUpsertChanges,
         ...workstreamUpsertChanges,
@@ -438,6 +486,7 @@ export function buildWorkspaceSyncPayloadModel(input) {
             sessionId,
             deletedAt: payloadBuiltAt
         })),
+        ...taskEventUpsertChanges,
         ...activeChanges,
         ...archivedChanges,
         ...Array.from(deleteTaskIds).map((taskId) => ({ op: 'delete', taskId }))
@@ -467,6 +516,7 @@ export function buildWorkspaceSyncPayloadModel(input) {
         currentAnnotatedAttachmentSessionIds,
         deleteAnnotatedAttachmentSessionIds,
         currentAnnotatedAttachmentSessionWatermarks,
+        currentTaskEventWatermarks,
         pushedWatermarks
     };
 }
@@ -516,6 +566,21 @@ export function buildWorkspaceSyncSignatureModel(input) {
                 .filter((profile) => profile.id.length > 0)
                 .sort((a, b) => a.id.localeCompare(b.id))
             : [],
+        taskEvents: Array.isArray(input.taskEvents)
+            ? input.taskEvents
+                .map((event) => ({
+                id: String(event.id || '').trim(),
+                taskId: String(event.taskId || '').trim(),
+                action: String(event.action || '').trim(),
+                actor: String(event.actor || '').trim(),
+                actorType: event.actorType === 'ai' || event.actorType === 'human' || event.actorType === 'system'
+                    ? event.actorType
+                    : 'system',
+                createdAt: String(event.createdAt || '').trim()
+            }))
+                .filter((event) => event.id.length > 0 && event.taskId.length > 0)
+                .sort((a, b) => a.id.localeCompare(b.id))
+            : [],
         documents: Array.isArray(input.documents)
             ? input.documents
                 .map((doc) => ({