@taskforcehq/taskforce 0.3.306 → 0.3.308

package/dist/sync/contentSyncState.js

@@ -1,6 +1,64 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createHash, randomUUID } from 'crypto';
+function decodeTaskforceContextPath(value, normalizePath) {
+    const normalized = String(value || '').trim();
+    if (!normalized.startsWith('/api/taskforce/context/'))
+        return null;
+    const encoded = normalized.slice('/api/taskforce/context/'.length).split(/[?#]/, 1)[0] || '';
+    if (!encoded)
+        return null;
+    try {
+        return normalizePath(decodeURIComponent(encoded));
+    }
+    catch {
+        return null;
+    }
+}
+function isAiProfileAvatarAssetPath(value, workspaceId) {
+    const normalized = String(value || '').replace(/\\/g, '/');
+    return normalized.startsWith(`workspaces/${workspaceId}/assets/images/ai-profiles/`)
+        && normalized.includes('/avatar/');
+}
+function inferBinaryAssetMimeType(assetPath) {
+    const ext = path.extname(assetPath).toLowerCase();
+    if (ext === '.png')
+        return 'image/png';
+    if (ext === '.jpg' || ext === '.jpeg')
+        return 'image/jpeg';
+    if (ext === '.webp')
+        return 'image/webp';
+    if (ext === '.gif')
+        return 'image/gif';
+    return 'application/octet-stream';
+}
+function inferAssetIdFromPath(assetPath) {
+    const match = String(assetPath || '').match(/(^|\/)(asset-[a-f0-9]{32})(?=[^/]*$)/i);
+    return match?.[2];
+}
+function listReferencedAiProfileAvatarAssetPaths(deps, workspaceId) {
+    const profiles = typeof deps.core.listAiProfiles === 'function'
+        ? deps.core.listAiProfiles(workspaceId, { includeArchived: true })
+        : [];
+    const referenced = new Map();
+    for (const profile of Array.isArray(profiles) ? profiles : []) {
+        const updatedAt = String(profile?.updatedAt || profile?.createdAt || '').trim();
+        for (const url of [profile?.avatarUrl, profile?.avatarSourceUrl]) {
+            const assetPath = decodeTaskforceContextPath(url, deps.normalizeTaskDataRelativePath);
+            if (!assetPath || !isAiProfileAvatarAssetPath(assetPath, workspaceId))
+                continue;
+            if (referenced.has(assetPath))
+                continue;
+            referenced.set(assetPath, {
+                updatedAt,
+                assetId: inferAssetIdFromPath(assetPath),
+                originalFilename: path.basename(assetPath),
+                mimeType: inferBinaryAssetMimeType(assetPath)
+            });
+        }
+    }
+    return referenced;
+}
 export function resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId) {
     if (!deps.workspaceAssetStore) {
         return {
@@ -19,6 +77,28 @@ export function resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId) {
     }
     return { primaryLink, effectiveUpdatedAt };
 }
+function resolveSyncLinkTarget(primaryLink) {
+    if (!primaryLink)
+        return null;
+    const targetId = String(primaryLink.targetId || primaryLink.taskId || '').trim();
+    if (!targetId)
+        return null;
+    const targetType = primaryLink.targetType === 'initiative' || primaryLink.targetType === 'workstream'
+        ? primaryLink.targetType
+        : 'task';
+    return { targetType, targetId };
+}
+function resolveIncomingSyncLinkTarget(input) {
+    const linkTargetType = input.linkTargetType === 'initiative' || input.linkTargetType === 'workstream' || input.linkTargetType === 'task'
+        ? input.linkTargetType
+        : null;
+    const linkTargetId = String(input.linkTargetId || '').trim();
+    if (linkTargetType && linkTargetId) {
+        return { targetType: linkTargetType, targetId: linkTargetId };
+    }
+    const taskId = String(input.taskId || '').trim();
+    return taskId ? { targetType: 'task', targetId: taskId } : null;
+}
 export function getCanonicalSyncDocumentMetadata(deps, relativePath, workspaceId) {
     if (!deps.workspaceAssetStore)
         return {};
@@ -26,12 +106,15 @@ export function getCanonicalSyncDocumentMetadata(deps, relativePath, workspaceId
     if (!asset || asset.kind !== 'document')
         return {};
     const { primaryLink } = resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId);
+    const linkTarget = resolveSyncLinkTarget(primaryLink);
     return {
         assetId: asset.assetId,
         documentId: asset.documentId,
         referenceNumber: asset.referenceNumber,
         version: asset.version,
-        taskId: primaryLink?.taskId || null,
+        taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+        linkTargetType: linkTarget?.targetType || null,
+        linkTargetId: linkTarget?.targetId || null,
         logicalName: asset.logicalName || null,
         caption: primaryLink?.displayName || null,
         originalFilename: asset.originalFilename || path.basename(relativePath),
@@ -63,9 +146,8 @@ export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc) {
     const normalizedIncomingFilename = typeof doc.originalFilename === 'string' && doc.originalFilename.trim().length > 0
         ? doc.originalFilename.trim()
         : null;
-    const normalizedIncomingTaskId = typeof doc.taskId === 'string' && doc.taskId.trim().length > 0
-        ? doc.taskId.trim()
-        : null;
+    const incomingLinkTarget = resolveIncomingSyncLinkTarget(doc);
+    const primaryLinkTarget = resolveSyncLinkTarget(primaryLink);
     const normalizedIncomingLinkRole = doc.linkRole === 'reference' ? 'reference' : 'attachment';
     const referenceNumberMismatch = Boolean(existingAsset.referenceNumber
         && normalizedIncomingReference
@@ -75,7 +157,8 @@ export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc) {
         || (existingAsset.documentId || null) !== normalizedIncomingDocumentId
         || (existingAsset.logicalName || null) !== normalizedIncomingLogicalName
         || (existingAsset.originalFilename || null) !== normalizedIncomingFilename
-        || (primaryLink?.taskId || null) !== normalizedIncomingTaskId
+        || (primaryLinkTarget?.targetType || null) !== (incomingLinkTarget?.targetType || null)
+        || (primaryLinkTarget?.targetId || null) !== (incomingLinkTarget?.targetId || null)
         || (primaryLink?.displayName || null) !== normalizedIncomingCaption
         || ((primaryLink?.role === 'reference' ? 'reference' : 'attachment')) !== normalizedIncomingLinkRole;
 }
@@ -98,9 +181,8 @@ export function hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset) {
     const normalizedIncomingFilename = typeof asset.originalFilename === 'string' && asset.originalFilename.trim().length > 0
         ? asset.originalFilename.trim()
         : null;
-    const normalizedIncomingTaskId = typeof asset.taskId === 'string' && asset.taskId.trim().length > 0
-        ? asset.taskId.trim()
-        : null;
+    const incomingLinkTarget = resolveIncomingSyncLinkTarget(asset);
+    const primaryLinkTarget = resolveSyncLinkTarget(primaryLink);
     const normalizedIncomingLinkRole = asset.linkRole === 'reference'
         ? 'reference'
         : asset.kind === 'image'
@@ -112,7 +194,8 @@ export function hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset) {
     return referenceNumberMismatch
         || (existingAsset.logicalName || null) !== normalizedIncomingLogicalName
         || (existingAsset.originalFilename || null) !== normalizedIncomingFilename
-        || (primaryLink?.taskId || null) !== normalizedIncomingTaskId
+        || (primaryLinkTarget?.targetType || null) !== (incomingLinkTarget?.targetType || null)
+        || (primaryLinkTarget?.targetId || null) !== (incomingLinkTarget?.targetId || null)
         || (primaryLink?.displayName || null) !== normalizedIncomingCaption
         || ((primaryLink?.role === 'reference'
             ? 'reference'
@@ -127,7 +210,7 @@ export function reconcileWorkspaceSyncLinks(deps, input) {
     const assetId = String(input.assetId || '').trim();
     if (!assetId)
         return;
-    const desiredTaskId = String(input.taskId || '').trim();
+    const desiredLinkTarget = resolveIncomingSyncLinkTarget(input);
     const desiredRole = input.role === 'reference'
         ? 'reference'
         : input.role === 'image'
@@ -135,21 +218,25 @@ export function reconcileWorkspaceSyncLinks(deps, input) {
             : 'attachment';
     const linkUpdatedAt = String(input.updatedAt || '').trim() || new Date().toISOString();
     const existingLinks = deps.workspaceAssetStore.listLinksForAsset(assetId, workspaceId, { includeDeleted: true });
-    if (desiredTaskId) {
+    if (desiredLinkTarget) {
         deps.workspaceAssetStore.upsertLink({
             workspaceId,
             assetId,
-            taskId: desiredTaskId,
+            targetType: desiredLinkTarget.targetType,
+            targetId: desiredLinkTarget.targetId,
             role: desiredRole,
             displayName: typeof input.displayName === 'string' && input.displayName.trim().length > 0 ? input.displayName.trim() : null,
             updatedAt: linkUpdatedAt,
             deletedAt: null
         });
     }
-    if (desiredTaskId) {
+    if (desiredLinkTarget) {
         for (const link of existingLinks) {
-            if (link.taskId === desiredTaskId && link.role === desiredRole)
+            if (link.targetType === desiredLinkTarget.targetType
+                && link.targetId === desiredLinkTarget.targetId
+                && link.role === desiredRole) {
                 continue;
+            }
             if (link.deletedAt)
                 continue;
             deps.workspaceAssetStore.deleteLink({
@@ -364,14 +451,13 @@ export async function listWorkspaceSyncDocumentIndex(deps, basePath, workspaceId
     return docs;
 }
 export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, workspaceId = 'default') {
-    if (!deps.workspaceAssetStore)
-        return [];
     const root = path.resolve(basePath);
     const objectStorageClient = deps.getObjectStorageClient();
-    const assets = deps.workspaceAssetStore.listAllByWorkspace(workspaceId, {
+    const assets = deps.workspaceAssetStore?.listAllByWorkspace(workspaceId, {
         includeDeleted: false
-    });
+    }) || [];
     const snapshots = [];
+    const emittedPaths = new Set();
     for (const asset of assets) {
         if (asset.kind !== 'image' && asset.kind !== 'file')
             continue;
@@ -382,6 +468,7 @@ export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, work
             continue;
         if (!deps.normalizeTaskDataRelativePath(storageKey))
             continue;
+        emittedPaths.add(storageKey);
         try {
             let buffer = null;
             if (asset.storageProvider === 'r2' && objectStorageClient) {
@@ -412,6 +499,7 @@ export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, work
                 continue;
             }
             const { primaryLink, effectiveUpdatedAt } = resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId);
+            const linkTarget = resolveSyncLinkTarget(primaryLink);
             snapshots.push({
                 path: storageKey,
                 updatedAt: effectiveUpdatedAt,
@@ -420,7 +508,9 @@ export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, work
                 kind: asset.kind,
                 mimeType: asset.mimeType || 'application/octet-stream',
                 referenceNumber: asset.referenceNumber,
-                taskId: primaryLink?.taskId || null,
+                taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+                linkTargetType: linkTarget?.targetType || null,
+                linkTargetId: linkTarget?.targetId || null,
                 logicalName: asset.logicalName || null,
                 caption: primaryLink?.displayName || null,
                 originalFilename: asset.originalFilename || path.basename(storageKey),
@@ -435,15 +525,56 @@ export async function listWorkspaceSyncBinaryAssetsSnapshot(deps, basePath, work
             });
         }
     }
+    const referencedAiAvatarAssets = listReferencedAiProfileAvatarAssetPaths(deps, workspaceId);
+    for (const [assetPath, metadata] of referencedAiAvatarAssets.entries()) {
+        if (emittedPaths.has(assetPath))
+            continue;
+        const absolutePath = path.resolve(root, assetPath);
+        if (absolutePath === root || !absolutePath.startsWith(`${root}${path.sep}`))
+            continue;
+        try {
+            let buffer = null;
+            if (objectStorageClient) {
+                const object = await objectStorageClient.getObject(assetPath);
+                buffer = object?.body || null;
+            }
+            else if (fs.existsSync(absolutePath)) {
+                buffer = fs.readFileSync(absolutePath);
+            }
+            if (!buffer)
+                continue;
+            snapshots.push({
+                path: assetPath,
+                updatedAt: metadata.updatedAt || new Date().toISOString(),
+                contentBase64: buffer.toString('base64'),
+                ...(metadata.assetId ? { assetId: metadata.assetId } : {}),
+                kind: 'image',
+                mimeType: metadata.mimeType,
+                referenceNumber: null,
+                taskId: null,
+                linkTargetType: null,
+                linkTargetId: null,
+                logicalName: null,
+                caption: null,
+                originalFilename: metadata.originalFilename,
+                linkRole: 'image'
+            });
+        }
+        catch (error) {
+            deps.recordSyncDiagnostic(workspaceId, 'pull', 'Failed to read referenced AI profile avatar asset.', {
+                source: 'assets.snapshot.aiProfileAvatar',
+                path: assetPath,
+                error: String(error?.message || error || '')
+            });
+        }
+    }
     return snapshots;
 }
 export async function listWorkspaceSyncBinaryAssetIndex(deps, workspaceId = 'default') {
-    if (!deps.workspaceAssetStore)
-        return [];
-    const assets = deps.workspaceAssetStore.listAllByWorkspace(workspaceId, {
+    const assets = deps.workspaceAssetStore?.listAllByWorkspace(workspaceId, {
         includeDeleted: false
-    });
-    return assets
+    }) || [];
+    const indexed = assets
         .filter((asset) => asset.kind === 'image' || asset.kind === 'file')
         .filter((asset) => asset.storageProvider !== 'external')
         .filter((asset) => {
@@ -453,6 +584,7 @@ export async function listWorkspaceSyncBinaryAssetIndex(deps, workspaceId = 'def
         .map((asset) => {
         const storageKey = String(asset.storageKey || '').trim();
         const { primaryLink, effectiveUpdatedAt } = resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId);
+        const linkTarget = resolveSyncLinkTarget(primaryLink);
         const assetKind = asset.kind === 'image' ? 'image' : 'file';
         return {
             path: storageKey,
@@ -461,7 +593,9 @@ export async function listWorkspaceSyncBinaryAssetIndex(deps, workspaceId = 'def
             kind: assetKind,
             mimeType: asset.mimeType || 'application/octet-stream',
             referenceNumber: asset.referenceNumber,
-            taskId: primaryLink?.taskId || null,
+            taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+            linkTargetType: linkTarget?.targetType || null,
+            linkTargetId: linkTarget?.targetId || null,
             logicalName: asset.logicalName || null,
             caption: primaryLink?.displayName || null,
             originalFilename: asset.originalFilename || path.basename(storageKey),
@@ -469,6 +603,29 @@ export async function listWorkspaceSyncBinaryAssetIndex(deps, workspaceId = 'def
         };
     })
         .filter((entry) => Number.isFinite(Date.parse(entry.updatedAt)) && entry.path.length > 0);
+    const indexedPaths = new Set(indexed.map((entry) => entry.path));
+    for (const [assetPath, metadata] of listReferencedAiProfileAvatarAssetPaths(deps, workspaceId).entries()) {
+        if (indexedPaths.has(assetPath))
+            continue;
+        if (!Number.isFinite(Date.parse(metadata.updatedAt)))
+            continue;
+        indexed.push({
+            path: assetPath,
+            updatedAt: metadata.updatedAt,
+            ...(metadata.assetId ? { assetId: metadata.assetId } : {}),
+            kind: 'image',
+            mimeType: metadata.mimeType,
+            referenceNumber: null,
+            taskId: null,
+            linkTargetType: null,
+            linkTargetId: null,
+            logicalName: null,
+            caption: null,
+            originalFilename: metadata.originalFilename,
+            linkRole: 'image'
+        });
+    }
+    return indexed;
 }
 export async function loadWorkspaceSyncDocumentPayload(deps, basePath, workspaceId, relativePath) {
     const normalizedPath = deps.normalizeWorkspaceSyncDocumentPath(relativePath);
@@ -571,16 +728,18 @@ export async function loadWorkspaceSyncBinaryAssetPayload(deps, basePath, worksp
     const normalizedPath = deps.normalizeTaskDataRelativePath(assetPath);
     if (!normalizedPath)
         return null;
-    if (!deps.workspaceAssetStore)
-        return null;
-    const asset = deps.workspaceAssetStore.getByStorageKey(normalizedPath, workspaceId);
-    if (!asset || (asset.kind !== 'image' && asset.kind !== 'file') || asset.storageProvider === 'external') {
+    const asset = deps.workspaceAssetStore?.getByStorageKey(normalizedPath, workspaceId) || null;
+    const referencedAiAvatar = !asset
+        ? listReferencedAiProfileAvatarAssetPaths(deps, workspaceId).get(normalizedPath) || null
+        : null;
+    if (!referencedAiAvatar
+        && (!asset || (asset.kind !== 'image' && asset.kind !== 'file') || asset.storageProvider === 'external')) {
         return null;
     }
     const objectStorageClient = deps.getObjectStorageClient();
     let buffer = null;
     try {
-        if (asset.storageProvider === 'r2' && objectStorageClient) {
+        if ((asset?.storageProvider === 'r2' || referencedAiAvatar) && objectStorageClient) {
             const object = await objectStorageClient.getObject(normalizedPath);
             buffer = object?.body || null;
         }
@@ -593,28 +752,59 @@ export async function loadWorkspaceSyncBinaryAssetPayload(deps, basePath, worksp
                 return null;
             buffer = fs.readFileSync(absolutePath);
         }
+        if (!buffer && referencedAiAvatar && objectStorageClient) {
+            const root = path.resolve(basePath);
+            const absolutePath = path.resolve(root, normalizedPath);
+            if (absolutePath !== root && absolutePath.startsWith(`${root}${path.sep}`) && fs.existsSync(absolutePath)) {
+                buffer = fs.readFileSync(absolutePath);
+            }
+        }
     }
     catch (error) {
         deps.recordSyncDiagnostic(workspaceId, 'pull', 'Failed to load targeted binary asset payload.', {
             source: 'assets.snapshot.loadPayload',
             path: normalizedPath,
-            assetId: asset.assetId,
+            assetId: asset?.assetId || referencedAiAvatar?.assetId,
             error: String(error?.message || error || '')
         });
         return null;
     }
     if (!buffer)
         return null;
+    if (!asset && referencedAiAvatar) {
+        return {
+            path: normalizedPath,
+            updatedAt: referencedAiAvatar.updatedAt || new Date().toISOString(),
+            contentBase64: buffer.toString('base64'),
+            ...(referencedAiAvatar.assetId ? { assetId: referencedAiAvatar.assetId } : {}),
+            kind: 'image',
+            mimeType: referencedAiAvatar.mimeType,
+            referenceNumber: null,
+            taskId: null,
+            linkTargetType: null,
+            linkTargetId: null,
+            logicalName: null,
+            caption: null,
+            originalFilename: referencedAiAvatar.originalFilename,
+            linkRole: 'image'
+        };
+    }
+    if (!asset)
+        return null;
     const { primaryLink, effectiveUpdatedAt } = resolveCanonicalAssetSyncLinkState(deps, asset, workspaceId);
+    const linkTarget = resolveSyncLinkTarget(primaryLink);
+    const assetKind = asset.kind === 'image' ? 'image' : 'file';
     return {
         path: normalizedPath,
         updatedAt: effectiveUpdatedAt,
         contentBase64: buffer.toString('base64'),
         assetId: asset.assetId,
-        kind: asset.kind,
+        kind: assetKind,
         mimeType: asset.mimeType || 'application/octet-stream',
         referenceNumber: asset.referenceNumber,
-        taskId: primaryLink?.taskId || null,
+        taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+        linkTargetType: linkTarget?.targetType || null,
+        linkTargetId: linkTarget?.targetId || null,
         logicalName: asset.logicalName || null,
         caption: primaryLink?.displayName || null,
         originalFilename: asset.originalFilename || path.basename(normalizedPath),
@@ -719,11 +909,13 @@ export async function writeWorkspaceSyncDocument(deps, basePath, doc, workspaceI
                 purgeAfter: null,
                 allowReferenceNumberReassignment
             });
-            const taskId = String(doc.taskId || '').trim();
+            const linkTarget = resolveIncomingSyncLinkTarget(doc);
             reconcileWorkspaceSyncLinks(deps, {
                 workspaceId,
                 assetId: asset.assetId,
-                taskId,
+                taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+                linkTargetType: linkTarget?.targetType || null,
+                linkTargetId: linkTarget?.targetId || null,
                 displayName: typeof doc.caption === 'string' && doc.caption.trim().length > 0 ? doc.caption.trim() : null,
                 role: doc.linkRole === 'reference' ? 'reference' : 'attachment',
                 updatedAt: effectiveUpdatedAt
@@ -811,11 +1003,13 @@ export async function writeWorkspaceSyncBinaryAsset(deps, basePath, asset, works
             purgeAfter: null,
             allowReferenceNumberReassignment
         });
-        const taskId = String(asset.taskId || '').trim();
+        const linkTarget = resolveIncomingSyncLinkTarget(asset);
         reconcileWorkspaceSyncLinks(deps, {
             workspaceId,
             assetId: assetRecord.assetId,
-            taskId,
+            taskId: linkTarget?.targetType === 'task' ? linkTarget.targetId : null,
+            linkTargetType: linkTarget?.targetType || null,
+            linkTargetId: linkTarget?.targetId || null,
             displayName: typeof asset.caption === 'string' && asset.caption.trim().length > 0 ? asset.caption.trim() : null,
             role: asset.linkRole === 'reference' ? 'reference' : asset.kind === 'image' ? 'image' : 'attachment',
             updatedAt: effectiveUpdatedAt

package/dist/sync/planningSyncPayload.js

@@ -23,6 +23,9 @@ function toOptionalInteger(value) {
         return null;
     return Math.floor(normalized);
 }
+function clonePlanningAttachments(value) {
+    return Array.isArray(value) ? value : undefined;
+}
 export function normalizeTaxonomySyncPayload(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return null;
@@ -56,6 +59,7 @@ export function normalizeInitiativeSyncPayload(raw, sourceWatermark) {
         createdAt: String(source.createdAt || sourceWatermark || '').trim(),
         updatedAt: String(source.updatedAt || sourceWatermark || source.createdAt || '').trim(),
         order: toOptionalInteger(source.order),
+        attachments: clonePlanningAttachments(source.attachments),
         isArchived: Boolean(source.isArchived),
     };
 }
@@ -77,6 +81,7 @@ export function normalizeWorkstreamSyncPayload(raw, sourceWatermark) {
         createdAt: String(source.createdAt || sourceWatermark || '').trim(),
         updatedAt: String(source.updatedAt || sourceWatermark || source.createdAt || '').trim(),
         order: toOptionalInteger(source.order),
+        attachments: clonePlanningAttachments(source.attachments),
         isArchived: Boolean(source.isArchived),
     };
 }

package/dist/sync/planningSyncPayload.test.js

@@ -22,6 +22,12 @@ describe('planningSyncPayload', () => {
             createdAt: '2026-04-10T10:00:00.000Z',
             updatedAt: '2026-04-10T11:00:00.000Z',
             order: '2',
+            attachments: [{
+                    path: 'workspaces/ws-1/assets/documents/asset-initiative.md',
+                    assetId: 'asset-initiative',
+                    referenceLabel: 'D-10',
+                    caption: 'Launch plan',
+                }],
             isArchived: true,
         });
         expect(initiative).toEqual({
@@ -34,6 +40,12 @@ describe('planningSyncPayload', () => {
             createdAt: '2026-04-10T10:00:00.000Z',
             updatedAt: '2026-04-10T11:00:00.000Z',
             order: 2,
+            attachments: [{
+                    path: 'workspaces/ws-1/assets/documents/asset-initiative.md',
+                    assetId: 'asset-initiative',
+                    referenceLabel: 'D-10',
+                    caption: 'Launch plan',
+                }],
             isArchived: true,
         });
     });
@@ -49,6 +61,12 @@ describe('planningSyncPayload', () => {
             createdAt: '2026-04-10T10:00:00.000Z',
             updatedAt: '2026-04-10T11:00:00.000Z',
             order: '5',
+            attachments: [{
+                    path: 'workspaces/ws-1/assets/documents/asset-workstream.md',
+                    assetId: 'asset-workstream',
+                    referenceLabel: 'D-11',
+                    caption: 'Backend plan',
+                }],
             isArchived: false,
         });
         expect(workstream).toEqual({
@@ -62,6 +80,12 @@ describe('planningSyncPayload', () => {
             createdAt: '2026-04-10T10:00:00.000Z',
             updatedAt: '2026-04-10T11:00:00.000Z',
             order: 5,
+            attachments: [{
+                    path: 'workspaces/ws-1/assets/documents/asset-workstream.md',
+                    assetId: 'asset-workstream',
+                    referenceLabel: 'D-11',
+                    caption: 'Backend plan',
+                }],
             isArchived: false,
         });
     });

package/dist/sync/syncApplyHandlers.d.ts

@@ -1,5 +1,5 @@
 import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
-import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncChange, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncTaskEventSnapshot, WorkspaceSyncTaskSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
+import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncChange, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncEntityEventSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncTaskSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
 import type { BinaryAssetSyncPayload, DocumentSyncPayload } from './contentSyncPayload.js';
 import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
 import type { AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
@@ -24,7 +24,7 @@ type NormalizeIncomingAiProfileSeatScope = (value: unknown, context: {
     profileId?: string;
     workspaceId?: string;
 }) => AiProfileSeatScope | null;
-type NormalizeTaskEventSyncPayload = (raw: unknown, workspaceId: string, sourceWatermark?: string) => WorkspaceSyncTaskEventSnapshot | null;
+type NormalizeTaskEventSyncPayload = (raw: unknown, workspaceId: string, sourceWatermark?: string) => WorkspaceSyncEntityEventSnapshot | null;
 export interface WorkspaceSyncIncomingTaskMutation {
     archived: boolean;
     task: WorkspaceSyncTaskSnapshot;
@@ -60,7 +60,7 @@ export interface WorkspaceSyncIncomingApplyModel {
         incomingAnnotatedAttachmentSessionDeletes: Map<string, string>;
     };
     taskActivity: {
-        incomingTaskEvents: Map<string, WorkspaceSyncTaskEventSnapshot>;
+        incomingTaskEvents: Map<string, WorkspaceSyncEntityEventSnapshot>;
     };
 }
 export interface PreparedWorkspaceTaskSyncSnapshot {
@@ -169,7 +169,7 @@ export declare function applyCollaborationSyncChanges(input: {
 export declare function applyTaskActivitySyncChanges(input: {
     core: SyncCore;
     workspaceId: string;
-    incomingTaskEvents: Map<string, WorkspaceSyncTaskEventSnapshot>;
+    incomingTaskEvents: Map<string, WorkspaceSyncEntityEventSnapshot>;
     recordSyncDiagnostic: RecordSyncDiagnostic;
     createSyncRouteError: CreateSyncRouteError;
 }): void;