@taskforcehq/taskforce 0.3.306 → 0.3.308

package/dist/sync/syncApplyHandlers.js

@@ -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);
             }
@@ -384,6 +386,8 @@ export function applyAiProfileAndMemberSyncChanges(input) {
                     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,
@@ -438,6 +442,20 @@ 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 {
@@ -448,17 +466,17 @@ export async function applyContentSyncChanges(input) {
                 const incomingHash = createHash('sha256').update(String(doc.content || '')).digest('hex');
                 const existingUpdatedAt = String(existingDoc?.updatedAt || existingDocFallback?.updatedAt || '').trim();
                 let existingHash = String(existingDoc?.contentHash || existingDocFallback?.contentHash || '').trim();
-                if (!existingHash && !hasObjectStorageClient()) {
+                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);
-                const metadataDrift = hasDocumentSyncMetadataDrift(workspaceId, doc, options);
                 if (compare < 0)
                     continue;
-                if (compare === 0 && existingHash === incomingHash && !metadataDrift)
+                if (compare === 0 && existingHash === incomingHash && !metadataDrift && !hasObjectStorageClient())
                     continue;
                 await writeWorkspaceSyncDocument(basePath, doc, workspaceId, {
                     ...options,
@@ -474,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 || '')
+                });
             }
         }
     }
@@ -497,14 +520,14 @@ export async function applyContentSyncChanges(input) {
                 const localFileMissing = !hasObjectStorageClient() && !fs.existsSync(localAssetPath);
                 const existingUpdatedAt = String(existing?.updatedAt || '').trim();
                 let existingHash = String(existing?.contentSha256 || '').trim();
-                if (!existingHash && !hasObjectStorageClient() && !localFileMissing) {
+                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);
-                const metadataDrift = hasBinaryAssetSyncMetadataDrift(workspaceId, asset, options);
                 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,
@@ -522,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);
@@ -760,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,
@@ -785,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,
@@ -796,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 });
         }
     }
 }

package/dist/sync/syncApplyHandlers.test.js

@@ -1,11 +1,16 @@
 import fs from 'node:fs';
 import { createHash } from 'node:crypto';
 import { describe, expect, it, vi, afterEach } from 'vitest';
-import { applyCollaborationSyncChanges, applyContentSyncChanges, applyPreparedTaskSyncSnapshot, applyTaskSyncDeletes, classifyWorkspaceSyncChanges, prepareTaskSyncSnapshotApply, } from './syncApplyHandlers.js';
+import { applyCollaborationSyncChanges, applyContentSyncChanges, applyPlanningSyncChanges, applyPreparedTaskSyncSnapshot, applyTaskActivitySyncChanges, applyTaskSyncDeletes, classifyWorkspaceSyncChanges, prepareTaskSyncSnapshotApply, } from './syncApplyHandlers.js';
 function createCoreFixture(overrides = {}) {
     return {
         resolveTaskIdentifier: vi.fn().mockReturnValue(null),
         getTask: vi.fn().mockReturnValue(null),
+        taskExistsForSync: vi.fn().mockReturnValue(true),
+        initiativeExistsForSync: vi.fn().mockReturnValue(true),
+        workstreamExistsForSync: vi.fn().mockReturnValue(true),
+        getTaskEventForSync: vi.fn().mockReturnValue(null),
+        getEntityEventForSync: vi.fn().mockReturnValue(null),
         deleteTaskForSync: vi.fn(),
         applyWorkspaceSyncSnapshot: vi.fn().mockReturnValue({
             total: 1,
@@ -185,6 +190,84 @@ describe('syncApplyHandlers', () => {
         }, workspaceId);
         expect(result).toEqual(expect.objectContaining({ total: 1 }));
     });
+    it('preserves planning attachments when applying initiative and workstream sync changes', () => {
+        const core = createCoreFixture({
+            upsertInitiativeForSync: vi.fn(),
+            upsertWorkstreamForSync: vi.fn(),
+            updateTaxonomies: vi.fn(),
+        });
+        applyPlanningSyncChanges({
+            core,
+            workspaceId: 'workspace-1',
+            incomingInitiatives: new Map([
+                ['initiative-1', {
+                        id: 'initiative-1',
+                        referenceNumber: 12,
+                        referenceLabel: 'I-12',
+                        title: 'Initiative',
+                        description: 'Initiative description',
+                        ownerId: null,
+                        createdAt: '2026-04-10T09:00:00.000Z',
+                        updatedAt: '2026-04-10T10:00:00.000Z',
+                        order: 1,
+                        attachments: [{
+                                path: '/api/taskforce/documents/asset-init-doc/content',
+                                fsPath: 'workspaces/workspace-1/assets/documents/initiative.md',
+                                assetId: 'asset-init-doc',
+                                caption: 'Initiative context',
+                                timestamp: '2026-04-10T10:00:00.000Z'
+                            }],
+                        isArchived: false,
+                    }],
+            ]),
+            incomingWorkstreams: new Map([
+                ['workstream-1', {
+                        id: 'workstream-1',
+                        referenceNumber: 689,
+                        referenceLabel: 'WS-689',
+                        initiativeId: 'initiative-1',
+                        title: 'Security Audit Remediation',
+                        description: 'Workstream description',
+                        ownerId: null,
+                        createdAt: '2026-04-10T09:00:00.000Z',
+                        updatedAt: '2026-04-10T10:00:00.000Z',
+                        order: 2,
+                        attachments: [{
+                                path: '/api/taskforce/documents/asset-workstream-doc/content',
+                                fsPath: 'workspaces/workspace-1/assets/documents/security-findings-register.md',
+                                assetId: 'asset-workstream-doc',
+                                caption: 'Living security findings register for WS-689',
+                                timestamp: '2026-04-10T10:00:00.000Z'
+                            }],
+                        isArchived: false,
+                    }],
+            ]),
+            incomingTaxonomies: null,
+            incomingTaxonomyState: null,
+            incomingTaxonomiesUpdatedAt: '',
+            workspaceTaxonomySyncMeta: new Map(),
+            recordSyncDiagnostic: vi.fn(),
+        });
+        expect(core.upsertInitiativeForSync).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'initiative-1',
+            attachments: [
+                expect.objectContaining({
+                    assetId: 'asset-init-doc',
+                    caption: 'Initiative context'
+                })
+            ]
+        }), 'workspace-1');
+        expect(core.upsertWorkstreamForSync).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'workstream-1',
+            referenceLabel: 'WS-689',
+            attachments: [
+                expect.objectContaining({
+                    assetId: 'asset-workstream-doc',
+                    caption: 'Living security findings register for WS-689'
+                })
+            ]
+        }), 'workspace-1');
+    });
     it('applies document and asset changes through the content handler helpers', async () => {
         const core = createCoreFixture();
         const writeWorkspaceSyncDocument = vi.fn().mockResolvedValue(undefined);
@@ -289,7 +372,7 @@ describe('syncApplyHandlers', () => {
         expect(writeWorkspaceSyncDocument).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'docs/spec.md' }), 'workspace-1', { allowReferenceNumberReassignment: true });
         expect(writeWorkspaceSyncBinaryAsset).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'assets/proof.png' }), 'workspace-1', { allowReferenceNumberReassignment: true });
     });
-    it('reuses persisted content hashes instead of re-reading unchanged local files', async () => {
+    it('reuses persisted content hashes instead of re-reading unchanged local files while reasserting object storage payloads', async () => {
         const existingDocContent = '# Spec';
         const existingAssetBytes = Buffer.from('png-bytes');
         const core = createCoreFixture({
@@ -347,8 +430,50 @@ describe('syncApplyHandlers', () => {
             recordSyncDiagnostic: vi.fn(),
         });
         expect(readSpy).not.toHaveBeenCalled();
-        expect(writeWorkspaceSyncDocument).not.toHaveBeenCalled();
-        expect(writeWorkspaceSyncBinaryAsset).not.toHaveBeenCalled();
+        expect(writeWorkspaceSyncDocument).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'docs/spec.md', assetId: 'asset-doc-1' }), 'workspace-1', { allowReferenceNumberReassignment: false });
+        expect(writeWorkspaceSyncBinaryAsset).toHaveBeenCalledWith('/tmp/taskforce-sync-content', expect.objectContaining({ path: 'assets/proof.png', assetId: 'asset-image-1' }), 'workspace-1', { allowReferenceNumberReassignment: false });
+    });
+    it('rejects synced content applies when a binary asset write fails', async () => {
+        const core = createCoreFixture();
+        const recordSyncDiagnostic = vi.fn();
+        await expect(applyContentSyncChanges({
+            core,
+            workspaceId: 'workspace-1',
+            incomingDocuments: [],
+            incomingDocumentDeletes: new Map(),
+            incomingAssets: [
+                {
+                    path: 'assets/proof.png',
+                    updatedAt: '2026-04-10T10:05:00.000Z',
+                    contentBase64: Buffer.from('png-bytes').toString('base64'),
+                    assetId: 'asset-image-1',
+                    kind: 'image',
+                    mimeType: 'image/png',
+                },
+            ],
+            incomingAssetDeletes: new Map(),
+            basePath: '/tmp/taskforce-sync-content',
+            hasObjectStorageClient: () => true,
+            hasDocumentSyncMetadataDrift: () => false,
+            hasBinaryAssetSyncMetadataDrift: () => false,
+            getExistingDocument: () => null,
+            writeWorkspaceSyncDocument: vi.fn(),
+            deleteWorkspaceSyncDocument: vi.fn(),
+            writeWorkspaceSyncBinaryAsset: vi.fn().mockRejectedValue(new Error('R2 write failed')),
+            deleteWorkspaceSyncBinaryAsset: vi.fn(),
+            getExistingBinaryAsset: () => null,
+            recordSyncDiagnostic,
+        })).rejects.toMatchObject({
+            code: 'SYNC_CONTENT_APPLY_FAILED',
+            statusCode: 500,
+        });
+        expect(recordSyncDiagnostic).toHaveBeenCalledWith('workspace-1', 'apply', 'Failed to apply synced asset change.', expect.objectContaining({
+            source: 'assets.apply.write',
+            path: 'assets/proof.png',
+            assetId: 'asset-image-1',
+            kind: 'image',
+            error: 'R2 write failed'
+        }));
     });
     it('applies collaboration upserts and deletes through the collaboration handlers', () => {
         const core = createCoreFixture();
@@ -443,4 +568,59 @@ describe('syncApplyHandlers', () => {
             deletedAt: '2026-04-10T11:10:00.000Z',
         });
     });
+    it('applies entity events through lean sync lookups instead of hydrated entity activity reads', () => {
+        const core = createCoreFixture({
+            taskExistsForSync: vi.fn().mockReturnValue(true),
+            getEntityEventForSync: vi.fn().mockReturnValue(null),
+            listTaskEvents: vi.fn(() => {
+                throw new Error('hydrated task activity lookup should not run during sync apply');
+            }),
+            getTask: vi.fn(() => {
+                throw new Error('hydrated task lookup should not run during sync apply');
+            }),
+            getInitiative: vi.fn(() => {
+                throw new Error('hydrated initiative lookup should not run during sync apply');
+            }),
+            getWorkstream: vi.fn(() => {
+                throw new Error('hydrated workstream lookup should not run during sync apply');
+            }),
+            listEntityEventsForSync: vi.fn(() => {
+                throw new Error('hydrated entity event listing should not run during sync apply');
+            }),
+            upsertEntityEventForSync: vi.fn(),
+        });
+        applyTaskActivitySyncChanges({
+            core,
+            workspaceId: 'workspace-1',
+            incomingTaskEvents: new Map([
+                ['task-event-1', {
+                        id: 'task-event-1',
+                        taskId: 'task-1',
+                        entityType: 'task',
+                        entityId: 'task-1',
+                        workspaceId: 'workspace-1',
+                        action: 'task-updated',
+                        actor: 'user-1',
+                        actorType: 'human',
+                        details: { changes: { status: { from: 'task', to: 'review' } } },
+                        createdAt: '2026-04-10T10:00:00.000Z',
+                    }],
+            ]),
+            recordSyncDiagnostic: vi.fn(),
+            createSyncRouteError: (message, details) => Object.assign(new Error(message), { details }),
+        });
+        expect(core.taskExistsForSync).toHaveBeenCalledWith('task-1', 'workspace-1');
+        expect(core.getEntityEventForSync).toHaveBeenCalledWith({
+            workspaceId: 'workspace-1',
+            eventId: 'task-event-1',
+        });
+        expect(core.upsertEntityEventForSync).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'task-event-1',
+            taskId: 'task-1',
+            entityType: 'task',
+            entityId: 'task-1',
+            workspaceId: 'workspace-1',
+            action: 'task-updated',
+        }));
+    });
 });

package/dist/sync/syncResourceAdapters.d.ts

@@ -9,6 +9,8 @@ export interface SyncAiProfileLike {
     color?: string | null;
     avatarUrl?: string | null;
     avatarSourceUrl?: string | null;
+    avatarRevision?: number | null;
+    avatarUpdatedAt?: string | null;
     description?: string | null;
     role?: string | null;
     provider?: string | null;

package/dist/sync/syncResourceAdapters.js

@@ -26,6 +26,8 @@ export function getAiProfileSyncChangeKey(profile) {
         color: String(source.color || '#8b5cf6').trim() || '#8b5cf6',
         avatarUrl: normalizeSyncSameOriginAssetUrl(source.avatarUrl) || '',
         avatarSourceUrl: normalizeSyncSameOriginAssetUrl(source.avatarSourceUrl) || '',
+        avatarRevision: Number.isFinite(Number(source.avatarRevision)) ? Math.max(0, Math.floor(Number(source.avatarRevision))) : 0,
+        avatarUpdatedAt: normalizeSyncNullableIsoString(source.avatarUpdatedAt) || '',
         description: normalizeSyncNullableString(source.description) || '',
         role: normalizeSyncNullableString(source.role) || '',
         provider: normalizeSyncNullableString(source.provider) || '',

package/dist/sync/syncService.d.ts

@@ -126,6 +126,7 @@ export interface WorkspacePullSyncResult {
     pulledActiveUpserts: boolean;
     pulledArchivedUpserts: boolean;
     pulledTaskEventUpserts?: boolean;
+    pulledPlanningUpserts?: boolean;
     documentDecryptFailures?: string[];
     emittedEventIds?: string[];
     serverDiagnostics?: Record<string, unknown> | null;

package/dist/sync/syncService.js

@@ -319,6 +319,7 @@ export async function runWorkspacePullSyncService(input) {
     let pulledActiveUpserts = false;
     let pulledArchivedUpserts = false;
     let pulledTaskEventUpserts = false;
+    let pulledPlanningUpserts = false;
     const documentDecryptFailures = new Set();
     const emittedEventIds = new Set();
     const pulledAnnotatedAttachmentSessionIds = new Set();
@@ -363,6 +364,7 @@ export async function runWorkspacePullSyncService(input) {
                     pulledActiveUpserts,
                     pulledArchivedUpserts,
                     pulledTaskEventUpserts,
+                    pulledPlanningUpserts,
                     documentDecryptFailures: Array.from(documentDecryptFailures),
                     serverDiagnostics: null
                 };
@@ -392,10 +394,14 @@ export async function runWorkspacePullSyncService(input) {
                         pulledAnnotatedAttachmentSessionIds.add(sessionId);
                     continue;
                 }
-                if (change.op === 'task-event-upsert') {
+                if (change.op === 'task-event-upsert' || change.op === 'entity-event-upsert') {
                     pulledTaskEventUpserts = true;
                     continue;
                 }
+                if (change.op === 'initiative-upsert' || change.op === 'workstream-upsert') {
+                    pulledPlanningUpserts = true;
+                    continue;
+                }
                 if (change.op === 'document-upsert') {
                     if (typeof change.content === 'string' && typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
                         try {
@@ -487,6 +493,7 @@ export async function runWorkspacePullSyncService(input) {
                         pulledActiveUpserts,
                         pulledArchivedUpserts,
                         pulledTaskEventUpserts,
+                        pulledPlanningUpserts,
                         documentDecryptFailures: Array.from(documentDecryptFailures),
                         emittedEventIds: Array.from(emittedEventIds),
                         serverDiagnostics: lastServerDiagnostics
@@ -509,6 +516,7 @@ export async function runWorkspacePullSyncService(input) {
                         pulledActiveUpserts,
                         pulledArchivedUpserts,
                         pulledTaskEventUpserts,
+                        pulledPlanningUpserts,
                         documentDecryptFailures: Array.from(documentDecryptFailures),
                         emittedEventIds: Array.from(emittedEventIds),
                         serverDiagnostics: lastServerDiagnostics
@@ -560,6 +568,7 @@ export async function runWorkspacePullSyncService(input) {
                         pulledActiveUpserts,
                         pulledArchivedUpserts,
                         pulledTaskEventUpserts,
+                        pulledPlanningUpserts,
                         documentDecryptFailures: Array.from(documentDecryptFailures),
                         emittedEventIds: Array.from(emittedEventIds),
                         serverDiagnostics: lastServerDiagnostics
@@ -589,6 +598,7 @@ export async function runWorkspacePullSyncService(input) {
                     pulledActiveUpserts,
                     pulledArchivedUpserts,
                     pulledTaskEventUpserts,
+                    pulledPlanningUpserts,
                     documentDecryptFailures: Array.from(documentDecryptFailures),
                     emittedEventIds: Array.from(emittedEventIds),
                     serverDiagnostics: lastServerDiagnostics
@@ -608,6 +618,7 @@ export async function runWorkspacePullSyncService(input) {
             pulledActiveUpserts,
             pulledArchivedUpserts,
             pulledTaskEventUpserts,
+            pulledPlanningUpserts,
             documentDecryptFailures: Array.from(documentDecryptFailures),
             emittedEventIds: Array.from(emittedEventIds),
             serverDiagnostics: lastServerDiagnostics
@@ -629,6 +640,7 @@ export async function runWorkspacePullSyncService(input) {
             pulledActiveUpserts,
             pulledArchivedUpserts,
             pulledTaskEventUpserts,
+            pulledPlanningUpserts,
             documentDecryptFailures: Array.from(documentDecryptFailures),
             emittedEventIds: Array.from(emittedEventIds),
             serverDiagnostics: null

package/dist/sync/syncService.test.js

@@ -548,6 +548,45 @@ describe('syncService', () => {
             expect(res.pulledActiveUpserts).toBe(false);
             expect(res.pulledArchivedUpserts).toBe(false);
         });
+        it('marks planning upserts when the pull contains initiative or workstream changes', async () => {
+            vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: {
+                    success: true,
+                    changes: [{
+                            op: 'workstream-upsert',
+                            updatedAt: '2026-04-27T22:00:00.000Z',
+                            workstream: {
+                                id: 'ws-123',
+                                title: 'Planning sync workstream',
+                                description: 'Contains planning attachments',
+                                createdAt: '2026-04-27T21:00:00.000Z',
+                                updatedAt: '2026-04-27T22:00:00.000Z',
+                                attachments: []
+                            }
+                        }],
+                    nextCursor: null,
+                    hasMore: false
+                }
+            });
+            vi.mocked(applyLocalWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                failures: [],
+                appliedCount: 1,
+                data: { success: true }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false
+            });
+            expect(res.success).toBe(true);
+            expect(res.pulledPlanningUpserts).toBe(true);
+            expect(res.pulledActiveUpserts).toBe(false);
+            expect(res.pulledArchivedUpserts).toBe(false);
+        });
         it('zero-change bootstrap pull (no changes, hasMore false) returns success true', async () => {
             vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
                 ok: true,

package/dist/sync/workspacePullFeed.d.ts

@@ -25,6 +25,10 @@ export interface WorkspacePullFeedResult {
         hydrationMs: number;
         encodeMs: number;
         buildMs: number;
+        snapshotErrors: Array<{
+            domain: string;
+            error: string;
+        }>;
     };
 }
 export declare function buildWorkspacePullFeed(input: {