@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/sync/workspacePullFeed.js

@@ -148,6 +148,14 @@ 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 assetEntries = assetIndex
         .map((asset) => ({
@@ -190,6 +198,7 @@ export async function buildWorkspacePullFeed(input) {
         ...documentReviewCommentDeleteEntries,
         ...annotatedAttachmentSessionEntries,
         ...annotatedAttachmentSessionDeleteEntries,
+        ...taskEventEntries,
         ...assetEntries,
         ...assetDeleteEntries
     ];
@@ -238,16 +247,11 @@ export async function buildWorkspacePullFeed(input) {
         }
     }));
     const hydrationMs = Date.now() - hydrationStartedAtMs;
-    const effectivePage = [];
-    for (const entry of page) {
-        if (entry.kind === 'document' && !hydratedDocuments.get(entry.path))
-            break;
-        if (entry.kind === 'asset' && !hydratedAssets.get(entry.path))
-            break;
-        effectivePage.push(entry);
-    }
-    const hasMore = afterCursor.length > effectivePage.length;
-    const last = effectivePage.length > 0 ? effectivePage[effectivePage.length - 1] : null;
+    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);
@@ -280,55 +284,57 @@ export async function buildWorkspacePullFeed(input) {
                                             ? [{ 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'
-                                                    ? (() => {
-                                                        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 === '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,
@@ -338,6 +344,7 @@ export async function buildWorkspacePullFeed(input) {
         diagnostics: {
             totalEntries: all.length,
             pageEntries: page.length,
+            skippedHydrationEntries,
             documentIndexCount: documentIndex.length,
             assetIndexCount: assetIndex.length,
             indexMs,

package/dist/sync/workspacePullFeed.test.js

@@ -29,6 +29,7 @@ function createCollaborationSyncStateMock() {
         listWorkspaceSyncDocumentReviewSessionsSnapshot: () => [],
         listWorkspaceSyncDocumentReviewCommentsSnapshot: () => [],
         listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: () => [],
+        listWorkspaceSyncTaskEventsSnapshot: () => [],
     };
 }
 function encodeCursor(cursor) {
@@ -234,9 +235,22 @@ describe('workspacePullFeed', () => {
         expect(loadedDocs).toEqual(['docs/a.md']);
         expect(loadedAssets).toEqual(['workspaces/ws/assets/images/a.png']);
     });
-    it('does not advance the cursor past a hydration miss', async () => {
+    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',
@@ -260,7 +274,7 @@ describe('workspacePullFeed', () => {
             core,
             workspaceId: 'workspace-4',
             cursor: null,
-            pageSize: 2,
+            pageSize: 3,
             encodeWorkspaceSyncCursor: encodeCursor,
             contentSyncState: content,
             collaborationSyncState: createCollaborationSyncStateMock(),
@@ -270,9 +284,63 @@ describe('workspacePullFeed', () => {
                 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' })
             })
         ]);
-        expect(result.nextCursor).toBe('2026-04-10T10:00:00.000Z|doc:docs/a.md');
-        expect(result.hasMore).toBe(true);
     });
 });

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;
@@ -104,6 +118,8 @@ export type WorkspaceSyncChange = {
 } | {
     op: 'delete';
     taskId: string;
+    deletedAt?: string;
+    watermark?: string;
 } | {
     op: 'initiative-upsert';
     initiative: WorkspaceSyncInitiativeSnapshot;
@@ -177,6 +193,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 +222,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>;
 }
@@ -240,6 +260,7 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     archivedTasks: TaskItem[];
     lastPushedTaskIds: Set<string>;
     pendingDeletedTaskIds: Set<string>;
+    pendingDeletedTaskWatermarks?: Map<string, string>;
     initiatives?: InitiativeItem[];
     workstreams?: WorkstreamItem[];
     taxonomies?: unknown[];
@@ -250,6 +271,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 +288,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 +312,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();
@@ -15,6 +25,9 @@ export function buildWorkspaceSyncPayloadModel(input) {
     const pendingDeleteIds = new Set(Array.from(input.pendingDeletedTaskIds)
         .map((taskId) => String(taskId || '').trim())
         .filter((taskId) => taskId.length > 0));
+    const pendingDeleteWatermarks = new Map(Array.from(input.pendingDeletedTaskWatermarks || new Map())
+        .map(([taskId, deletedAt]) => [String(taskId || '').trim(), String(deletedAt || '').trim()])
+        .filter(([taskId, deletedAt]) => taskId.length > 0 && Number.isFinite(Date.parse(deletedAt))));
     const lastWatermarks = input.lastPushedWatermarks;
     const isDirty = (task) => {
         if ((task?.referenceNumber === undefined || task?.referenceNumber === null) && Number.isFinite(Number(task?.localReferenceNumber))) {
@@ -64,12 +77,14 @@ export function buildWorkspaceSyncPayloadModel(input) {
         .filter((taskId) => !currentTaskIds.has(taskId))
         .map((taskId) => ({
         op: 'delete',
-        taskId
+        taskId,
+        deletedAt: pendingDeleteWatermarks.get(taskId) || payloadBuiltAt
     }));
     const queuedDeleteChanges = Array.from(pendingDeleteIds)
         .map((taskId) => ({
         op: 'delete',
-        taskId
+        taskId,
+        deletedAt: pendingDeleteWatermarks.get(taskId) || payloadBuiltAt
     }));
     const deleteTaskIds = new Set([
         ...deleteChanges.map((change) => String(change.taskId)),
@@ -175,6 +190,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 +410,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,9 +491,14 @@ export function buildWorkspaceSyncPayloadModel(input) {
             sessionId,
             deletedAt: payloadBuiltAt
         })),
+        ...taskEventUpsertChanges,
         ...activeChanges,
         ...archivedChanges,
-        ...Array.from(deleteTaskIds).map((taskId) => ({ op: 'delete', taskId }))
+        ...Array.from(deleteTaskIds).map((taskId) => ({
+            op: 'delete',
+            taskId,
+            deletedAt: pendingDeleteWatermarks.get(taskId) || payloadBuiltAt
+        }))
     ];
     return {
         changes,
@@ -467,6 +525,7 @@ export function buildWorkspaceSyncPayloadModel(input) {
         currentAnnotatedAttachmentSessionIds,
         deleteAnnotatedAttachmentSessionIds,
         currentAnnotatedAttachmentSessionWatermarks,
+        currentTaskEventWatermarks,
         pushedWatermarks
     };
 }
@@ -516,6 +575,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) => ({