@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/sync/workspacePullFeed.js

@@ -1,13 +1,39 @@
 import { serializeTaskForSync } from './taskSyncPayload.js';
+import { aiProfileSyncResourceAdapter, taskSyncResourceAdapter } from './syncResourceAdapters.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;
+    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) => {
-        const watermark = String(entry.task?.updatedAt || entry.task?.createdAt || '').trim();
+        const watermark = taskSyncResourceAdapter.getWatermark(entry.task);
         const taskId = String(entry.task?.id || '').trim();
         return {
             kind: 'upsert',
@@ -27,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())))
@@ -39,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(),
@@ -47,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(),
@@ -55,16 +81,16 @@ export async function buildWorkspacePullFeed(input) {
         workstream
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.workstream.id.length > 0);
-    const aiProfileEntries = core.listAiProfiles(workspaceId)
+    const aiProfileEntries = readSnapshot('ai-profiles', [], () => core.listAiProfiles(workspaceId, { includeArchived: true }))
         .map((profile) => ({
         kind: 'ai-profile',
-        watermark: String(profile.updatedAt || profile.createdAt || '').trim(),
+        watermark: aiProfileSyncResourceAdapter.getWatermark(profile),
         sortId: `ai-profile:${String(profile.id || '').trim()}`,
         profile
     }))
         .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',
@@ -76,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(),
@@ -91,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) => ({
@@ -110,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) => ({
@@ -129,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) => ({
@@ -148,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',
@@ -168,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(),
@@ -217,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,
@@ -286,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,
@@ -350,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

@@ -126,6 +126,7 @@ describe('workspacePullFeed', () => {
                 userId: 'user-1',
                 email: 'person@example.com',
                 displayName: 'Person',
+                avatarUrl: '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Fheadshot.webp',
                 role: 'owner',
                 permissionMode: 'read-write',
                 betaAccess: true,
@@ -167,6 +168,97 @@ describe('workspacePullFeed', () => {
                 displayName: 'Person',
             })
         ]);
+        expect(result.workspaceMembers[0]).not.toHaveProperty('avatarUrl');
+    });
+    it('includes ai-profile upserts with avatar fields in the pull feed', async () => {
+        const core = createCoreMock();
+        core.listAiProfiles = () => [
+            {
+                id: 'ai-profile-1',
+                workspaceId: 'workspace-1',
+                profileToken: 'tfp_test',
+                name: 'Codex',
+                username: 'codex',
+                icon: 'Bot',
+                color: '#0ea5e9',
+                avatarUrl: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fai-profile-1%2Favatar%2Favatar.webp',
+                avatarSourceUrl: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fai-profile-1%2Favatar%2Fsource.webp',
+                createdAt: '2026-04-10T10:00:00.000Z',
+                updatedAt: '2026-04-10T10:05:00.000Z',
+                lastActiveAt: '2026-04-10T10:05:00.000Z'
+            }
+        ];
+        const result = await buildWorkspacePullFeed({
+            core,
+            workspaceId: 'workspace-1',
+            cursor: null,
+            pageSize: 10,
+            encodeWorkspaceSyncCursor: encodeCursor,
+            contentSyncState: createContentSyncStateMock(),
+            collaborationSyncState: createCollaborationSyncStateMock(),
+        });
+        expect(result.changes).toEqual([
+            expect.objectContaining({
+                op: 'ai-profile-upsert',
+                watermark: '2026-04-10T10:05:00.000Z',
+                profile: expect.objectContaining({
+                    id: 'ai-profile-1',
+                    avatarUrl: expect.stringContaining('/api/taskforce/context/'),
+                    avatarSourceUrl: expect.stringContaining('/api/taskforce/context/')
+                })
+            })
+        ]);
+        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();

package/dist/sync/workspaceRepair.js

@@ -338,8 +338,9 @@ export function scanWorkspaceRepair(input) {
         for (const asset of assets) {
             const links = input.workspaceAssetStore.listLinksForAsset(asset.assetId, snapshot.workspaceId, { includeDeleted: false });
             for (const link of links) {
-                if (activeTaskIds.has(link.taskId))
+                if (link.targetType === 'task' && link.taskId && activeTaskIds.has(link.taskId))
                     continue;
+                const linkedTargetId = link.targetId;
                 issues.push({
                     code: 'stale_asset_link',
                     entityKind: 'link',
@@ -349,7 +350,9 @@ export function scanWorkspaceRepair(input) {
                     role: link.role,
                     repairable: true,
                     recommendedAction: 'delete-link',
-                    detail: 'Canonical asset link points to a task that no longer exists in this workspace.'
+                    detail: link.targetType === 'task'
+                        ? 'Canonical asset link points to a task that no longer exists in this workspace.'
+                        : `Canonical asset link points to a missing ${link.targetType} target (${linkedTargetId}).`
                 });
             }
         }