@taskforcehq/taskforce 0.3.305 → 0.3.307

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,7 +1,8 @@
 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';
 type SyncCore = TaskforceCore & TaskforceSyncCapable;
 type SyncRouteError = Error & {
     code?: string;
@@ -18,7 +19,12 @@ type NormalizeIncomingAiProfileSurfaceType = (value: unknown, context: {
     profileId?: string;
     workspaceId?: string;
 }) => AiProfileSurfaceType | null;
-type NormalizeTaskEventSyncPayload = (raw: unknown, workspaceId: string, sourceWatermark?: string) => WorkspaceSyncTaskEventSnapshot | null;
+type NormalizeIncomingAiProfileSeatScope = (value: unknown, context: {
+    source: string;
+    profileId?: string;
+    workspaceId?: string;
+}) => AiProfileSeatScope | null;
+type NormalizeTaskEventSyncPayload = (raw: unknown, workspaceId: string, sourceWatermark?: string) => WorkspaceSyncEntityEventSnapshot | null;
 export interface WorkspaceSyncIncomingTaskMutation {
     archived: boolean;
     task: WorkspaceSyncTaskSnapshot;
@@ -54,7 +60,7 @@ export interface WorkspaceSyncIncomingApplyModel {
         incomingAnnotatedAttachmentSessionDeletes: Map<string, string>;
     };
     taskActivity: {
-        incomingTaskEvents: Map<string, WorkspaceSyncTaskEventSnapshot>;
+        incomingTaskEvents: Map<string, WorkspaceSyncEntityEventSnapshot>;
     };
 }
 export interface PreparedWorkspaceTaskSyncSnapshot {
@@ -68,6 +74,7 @@ export declare function classifyWorkspaceSyncChanges(input: {
     normalizeWorkspaceSyncDocumentPath: (rawPath: unknown) => string | null;
     normalizeTaskAssetPath: (rawPath: unknown) => string | null;
     normalizeIncomingAiProfileSurfaceType: NormalizeIncomingAiProfileSurfaceType;
+    normalizeIncomingAiProfileSeatScope: NormalizeIncomingAiProfileSeatScope;
     normalizeTaskEventSyncPayload: NormalizeTaskEventSyncPayload;
     recordSyncDiagnostic: RecordSyncDiagnostic;
 }): WorkspaceSyncIncomingApplyModel;
@@ -162,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;

package/dist/sync/syncApplyHandlers.js

@@ -83,7 +83,7 @@ function recordTaskReferenceNumberMismatch(input) {
     return true;
 }
 export function classifyWorkspaceSyncChanges(input) {
-    const { workspaceId, incomingChanges, normalizeWorkspaceSyncDocumentPath, normalizeTaskAssetPath, normalizeIncomingAiProfileSurfaceType, normalizeTaskEventSyncPayload, recordSyncDiagnostic, } = input;
+    const { workspaceId, incomingChanges, normalizeWorkspaceSyncDocumentPath, normalizeTaskAssetPath, normalizeIncomingAiProfileSurfaceType, normalizeIncomingAiProfileSeatScope, normalizeTaskEventSyncPayload, recordSyncDiagnostic, } = input;
     const model = createIncomingApplyModel();
     for (const change of incomingChanges) {
         const raw = change;
@@ -111,7 +111,7 @@ export function classifyWorkspaceSyncChanges(input) {
             continue;
         }
         if (op === 'ai-profile-upsert') {
-            const profile = normalizeAiProfileSyncPayload(raw.profile, workspaceId, normalizeIncomingAiProfileSurfaceType, 'apply.aiProfileUpsert');
+            const profile = normalizeAiProfileSyncPayload(raw.profile, workspaceId, normalizeIncomingAiProfileSurfaceType, normalizeIncomingAiProfileSeatScope, 'apply.aiProfileUpsert');
             const profileId = String(profile?.id || '').trim();
             if (profileId && profile) {
                 const profileWorkspaceId = String(profile.workspaceId || '').trim();
@@ -194,7 +194,7 @@ export function classifyWorkspaceSyncChanges(input) {
                 model.collaboration.incomingAnnotatedAttachmentSessionDeletes.set(deletedSession.id, deletedSession.deletedAt);
             continue;
         }
-        if (op === 'task-event-upsert') {
+        if (op === 'task-event-upsert' || op === 'entity-event-upsert') {
             const event = normalizeTaskEventSyncPayload(raw.event, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
             if (event)
                 model.taskActivity.incomingTaskEvents.set(event.id, event);
@@ -295,6 +295,7 @@ export function applyPlanningSyncChanges(input) {
                     createdAt: initiative.createdAt,
                     updatedAt: initiative.updatedAt,
                     order: initiative.order,
+                    attachments: initiative.attachments,
                     isArchived: initiative.isArchived
                 }, workspaceId);
             }
@@ -322,6 +323,7 @@ export function applyPlanningSyncChanges(input) {
                     createdAt: workstream.createdAt,
                     updatedAt: workstream.updatedAt,
                     order: workstream.order,
+                    attachments: workstream.attachments,
                     isArchived: workstream.isArchived
                 }, workspaceId);
             }
@@ -382,12 +384,22 @@ export function applyAiProfileAndMemberSyncChanges(input) {
                     username: profile.username,
                     icon: profile.icon,
                     color: profile.color,
+                    ...(Object.prototype.hasOwnProperty.call(profile, 'avatarUrl') ? { avatarUrl: profile.avatarUrl ?? null } : {}),
+                    ...(Object.prototype.hasOwnProperty.call(profile, 'avatarSourceUrl') ? { avatarSourceUrl: profile.avatarSourceUrl ?? null } : {}),
+                    ...(Object.prototype.hasOwnProperty.call(profile, 'avatarRevision') ? { avatarRevision: profile.avatarRevision ?? 0 } : {}),
+                    avatarUpdatedAt: profile.avatarUpdatedAt ?? null,
                     description: profile.description ?? null,
                     role: profile.role ?? null,
                     provider: profile.provider ?? null,
                     model: profile.model ?? null,
                     surfaceType: profile.surfaceType,
+                    seatScope: profile.seatScope ?? null,
                     providerMetadata: profile.providerMetadata,
+                    archivedAt: profile.archivedAt ?? null,
+                    archivedBy: profile.archivedBy ?? null,
+                    archivedReason: profile.archivedReason ?? null,
+                    mergedIntoProfileId: profile.mergedIntoProfileId ?? null,
+                    rosterStateUpdatedAt: profile.rosterStateUpdatedAt ?? null,
                     createdAt: profile.createdAt,
                     updatedAt: profile.updatedAt,
                     lastActiveAt: profile.lastActiveAt
@@ -430,27 +442,47 @@ export function applyAiProfileAndMemberSyncChanges(input) {
 }
 export async function applyContentSyncChanges(input) {
     const { core, workspaceId, incomingDocuments, incomingDocumentDeletes, incomingAssets, incomingAssetDeletes, basePath, hasObjectStorageClient, hasDocumentSyncMetadataDrift, hasBinaryAssetSyncMetadataDrift, getExistingDocument, writeWorkspaceSyncDocument, deleteWorkspaceSyncDocument, writeWorkspaceSyncBinaryAsset, deleteWorkspaceSyncBinaryAsset, getExistingBinaryAsset, recordSyncDiagnostic, options, } = input;
+    const contentApplyFailures = [];
+    const recordContentApplyFailure = (failure) => {
+        contentApplyFailures.push(failure);
+    };
+    const throwIfContentApplyFailed = () => {
+        if (contentApplyFailures.length === 0)
+            return;
+        const first = contentApplyFailures[0];
+        const error = new Error(`Failed to apply ${contentApplyFailures.length} synced content change${contentApplyFailures.length === 1 ? '' : 's'}; first failure: ${first.kind} ${first.path}: ${first.error}`);
+        error.statusCode = 500;
+        error.code = 'SYNC_CONTENT_APPLY_FAILED';
+        error.details = { failures: contentApplyFailures.slice(0, 10) };
+        throw error;
+    };
     if (incomingDocuments.length > 0) {
         for (const doc of incomingDocuments) {
             try {
                 const existingDoc = core.getDocumentWatermark(workspaceId, doc.path);
-                const existingDocFallback = getExistingDocument ? getExistingDocument(doc.path, workspaceId) : null;
-                const localDocumentPath = path.resolve(basePath, doc.path);
-                const localDocumentHash = !hasObjectStorageClient() && fs.existsSync(localDocumentPath)
-                    ? createHash('sha256').update(fs.readFileSync(localDocumentPath, 'utf8')).digest('hex')
-                    : '';
+                const existingDocFallback = (!existingDoc && getExistingDocument)
+                    ? getExistingDocument(doc.path, workspaceId)
+                    : null;
                 const incomingHash = createHash('sha256').update(String(doc.content || '')).digest('hex');
                 const existingUpdatedAt = String(existingDoc?.updatedAt || existingDocFallback?.updatedAt || '').trim();
-                const existingHash = String(existingDoc?.contentHash || localDocumentHash || existingDocFallback?.contentHash || '').trim();
-                const compare = resolveSyncConflictOrdering(doc.updatedAt, existingUpdatedAt, incomingHash, existingHash);
+                let existingHash = String(existingDoc?.contentHash || existingDocFallback?.contentHash || '').trim();
                 const metadataDrift = hasDocumentSyncMetadataDrift(workspaceId, doc, options);
+                if (!hasObjectStorageClient() && (!existingHash || metadataDrift)) {
+                    const localDocumentPath = path.resolve(basePath, doc.path);
+                    if (fs.existsSync(localDocumentPath)) {
+                        existingHash = createHash('sha256').update(fs.readFileSync(localDocumentPath, 'utf8')).digest('hex');
+                    }
+                }
+                const compare = resolveSyncConflictOrdering(doc.updatedAt, existingUpdatedAt, incomingHash, existingHash);
                 if (compare < 0)
                     continue;
-                if (compare === 0 && existingHash === incomingHash && !metadataDrift)
+                if (compare === 0 && existingHash === incomingHash && !metadataDrift && !hasObjectStorageClient())
                     continue;
                 await writeWorkspaceSyncDocument(basePath, doc, workspaceId, {
                     ...options,
-                    allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true || existingHash !== incomingHash
+                    allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true
+                        || existingHash !== incomingHash
+                        || metadataDrift
                 });
             }
             catch (error) {
@@ -460,6 +492,11 @@ export async function applyContentSyncChanges(input) {
                     assetId: typeof doc.assetId === 'string' ? doc.assetId : null,
                     error: String(error?.message || error || '')
                 });
+                recordContentApplyFailure({
+                    kind: 'document',
+                    path: doc.path,
+                    error: String(error?.message || error || '')
+                });
             }
         }
     }
@@ -481,22 +518,23 @@ export async function applyContentSyncChanges(input) {
                 const existing = getExistingBinaryAsset(asset.path, workspaceId);
                 const incomingHash = createHash('sha256').update(Buffer.from(String(asset.contentBase64 || ''), 'base64')).digest('hex');
                 const localFileMissing = !hasObjectStorageClient() && !fs.existsSync(localAssetPath);
-                const localAssetHash = !hasObjectStorageClient() && !localFileMissing
-                    ? createHash('sha256').update(fs.readFileSync(localAssetPath)).digest('hex')
-                    : '';
                 const existingUpdatedAt = String(existing?.updatedAt || '').trim();
-                const existingHash = String(localAssetHash || existing?.contentSha256 || '').trim();
-                const compare = resolveSyncConflictOrdering(asset.updatedAt, existingUpdatedAt, incomingHash, existingHash);
+                let existingHash = String(existing?.contentSha256 || '').trim();
                 const metadataDrift = hasBinaryAssetSyncMetadataDrift(workspaceId, asset, options);
+                if (!hasObjectStorageClient() && !localFileMissing && (!existingHash || metadataDrift)) {
+                    existingHash = createHash('sha256').update(fs.readFileSync(localAssetPath)).digest('hex');
+                }
+                const compare = resolveSyncConflictOrdering(asset.updatedAt, existingUpdatedAt, incomingHash, existingHash);
                 if (compare < 0)
                     continue;
-                if (compare === 0 && existingHash === incomingHash && !localFileMissing && !metadataDrift)
+                if (compare === 0 && existingHash === incomingHash && !localFileMissing && !metadataDrift && !hasObjectStorageClient())
                     continue;
                 await writeWorkspaceSyncBinaryAsset(basePath, asset, workspaceId, {
                     ...options,
                     allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true
                         || existingHash !== incomingHash
                         || localFileMissing
+                        || metadataDrift
                 });
             }
             catch (error) {
@@ -507,9 +545,15 @@ export async function applyContentSyncChanges(input) {
                     kind: asset.kind,
                     error: String(error?.message || error || '')
                 });
+                recordContentApplyFailure({
+                    kind: 'asset',
+                    path: asset.path,
+                    error: String(error?.message || error || '')
+                });
             }
         }
     }
+    throwIfContentApplyFailed();
     if (incomingAssetDeletes.size > 0) {
         for (const [assetPath, deletedAt] of incomingAssetDeletes.entries()) {
             const existing = getExistingBinaryAsset(assetPath, workspaceId);
@@ -745,22 +789,32 @@ export function applyTaskActivitySyncChanges(input) {
         return;
     for (const event of incomingTaskEvents.values()) {
         try {
-            const taskId = String(event.taskId || '').trim();
-            if (!taskId)
+            const entityType = event.entityType === 'initiative' || event.entityType === 'workstream' ? event.entityType : 'task';
+            const entityId = String(event.entityId || event.taskId || '').trim();
+            if (!entityId)
                 continue;
-            const existingTask = core.getTask(taskId, workspaceId);
-            if (!existingTask) {
-                recordSyncDiagnostic(workspaceId, 'apply', 'Skipped task event during sync apply because the task does not exist locally.', {
-                    source: 'apply.taskEventMissingTask',
+            const entityExists = entityType === 'task'
+                ? core.taskExistsForSync(entityId, workspaceId)
+                : entityType === 'initiative'
+                    ? core.initiativeExistsForSync(entityId, workspaceId)
+                    : core.workstreamExistsForSync(entityId, workspaceId);
+            if (!entityExists) {
+                recordSyncDiagnostic(workspaceId, 'apply', 'Skipped entity event during sync apply because the entity does not exist locally.', {
+                    source: 'apply.entityEventMissingEntity',
                     eventId: event.id,
-                    taskId,
+                    entityType,
+                    entityId,
                 });
                 continue;
             }
-            const existing = core.listTaskEvents(taskId, workspaceId).find((entry) => entry.id === event.id) || null;
+            const existing = core.getEntityEventForSync({
+                workspaceId,
+                eventId: event.id,
+            });
             const incomingTieBreak = createHash('sha256')
                 .update(JSON.stringify({
-                taskId,
+                entityType,
+                entityId,
                 action: event.action,
                 actor: event.actor,
                 actorType: event.actorType,
@@ -770,7 +824,8 @@ export function applyTaskActivitySyncChanges(input) {
             const existingTieBreak = existing
                 ? createHash('sha256')
                     .update(JSON.stringify({
-                    taskId: existing.taskId,
+                    entityType: existing.entityType,
+                    entityId: existing.entityId || ('taskId' in existing ? existing.taskId : ''),
                     action: existing.action,
                     actor: existing.actor,
                     actorType: existing.actorType,
@@ -781,27 +836,45 @@ export function applyTaskActivitySyncChanges(input) {
             const compare = resolveSyncConflictOrdering(event.createdAt, String(existing?.createdAt || '').trim(), incomingTieBreak, existingTieBreak);
             if (compare < 0)
                 continue;
-            core.upsertTaskEventForSync({
-                id: event.id,
-                taskId,
-                workspaceId,
-                action: event.action,
-                actor: event.actor,
-                actorType: event.actorType,
-                details: event.details,
-                createdAt: event.createdAt,
-            });
+            if (entityType === 'task') {
+                core.upsertEntityEventForSync({
+                    id: event.id,
+                    workspaceId,
+                    entityType: 'task',
+                    entityId,
+                    taskId: String(event.taskId || entityId).trim(),
+                    action: event.action,
+                    actor: event.actor,
+                    actorType: event.actorType,
+                    details: event.details,
+                    createdAt: event.createdAt,
+                });
+            }
+            else {
+                core.upsertEntityEventForSync({
+                    id: event.id,
+                    workspaceId,
+                    entityType,
+                    entityId,
+                    action: event.action,
+                    actor: event.actor,
+                    actorType: event.actorType,
+                    details: event.details,
+                    createdAt: event.createdAt,
+                });
+            }
         }
         catch (error) {
             const details = {
-                source: 'apply.taskEventUpsert',
+                source: 'apply.entityEventUpsert',
                 eventId: event.id,
-                taskId: event.taskId,
+                entityType: event.entityType,
+                entityId: event.entityId || event.taskId,
                 error: String(error?.message || error || ''),
                 errorCode: String(error?.code || '').trim() || null
             };
-            recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert task event during sync apply.', details);
-            throw createSyncRouteError(`Failed to persist task event ${event.id} during sync apply: ${String(error?.message || error || 'Unknown error')}`, details, { code: 'TASK_EVENT_SYNC_APPLY_FAILED', statusCode: 500 });
+            recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert entity event during sync apply.', details);
+            throw createSyncRouteError(`Failed to persist entity event ${event.id} during sync apply: ${String(error?.message || error || 'Unknown error')}`, details, { code: 'TASK_EVENT_SYNC_APPLY_FAILED', statusCode: 500 });
         }
     }
 }