@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/sync/cloudSyncApi.test.js

@@ -18,7 +18,7 @@ describe('cloudSyncApi.applyLocalWorkspaceChanges', () => {
         expect(fetchMock).toHaveBeenCalledTimes(1);
         expect(fetchMock).toHaveBeenCalledWith('/api/taskforce/sync/workspace/apply-local', expect.any(Object));
     });
-    it('uses canonical /taskforce apply endpoint when running under /taskforce path', async () => {
+    it('keeps the canonical local apply endpoint when running under /taskforce path', async () => {
         window.history.replaceState({}, '', '/taskforce');
         const fetchMock = vi.fn().mockResolvedValue({
             ok: true,
@@ -29,13 +29,70 @@ describe('cloudSyncApi.applyLocalWorkspaceChanges', () => {
         const result = await applyLocalWorkspaceChanges('ws-2', [{ op: 'delete', taskId: 't-2' }]);
         expect(result.ok).toBe(true);
         expect(fetchMock).toHaveBeenCalledTimes(1);
-        expect(fetchMock).toHaveBeenCalledWith('/taskforce/api/taskforce/sync/workspace/apply-local', expect.any(Object));
+        expect(fetchMock).toHaveBeenCalledWith('/api/taskforce/sync/workspace/apply-local', expect.any(Object));
+    });
+    it('includes bootstrap snapshot reconciliation metadata when provided', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ success: true })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await applyLocalWorkspaceChanges('ws-bootstrap', [], {
+            bootstrapSnapshot: {
+                currentAnnotatedAttachmentSessionIds: ['session-1', 'session-2']
+            }
+        });
+        expect(result.ok).toBe(true);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        const [, requestInit] = fetchMock.mock.calls[0] || [];
+        expect(typeof requestInit?.body).toBe('string');
+        expect(JSON.parse(String(requestInit?.body))).toMatchObject({
+            workspaceId: 'ws-bootstrap',
+            bootstrapSnapshot: {
+                currentAnnotatedAttachmentSessionIds: ['session-1', 'session-2']
+            }
+        });
+    });
+    it('includes workspace members when provided', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ success: true })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await applyLocalWorkspaceChanges('ws-members', [], {
+            workspaceMembers: [
+                {
+                    userId: 'user-1',
+                    workspaceId: 'ws-members',
+                    email: 'member@example.com',
+                    displayName: 'Member One',
+                    role: 'member',
+                    permissionMode: 'read-write',
+                    betaAccess: true,
+                    status: 'active',
+                    disabled: false
+                }
+            ]
+        });
+        expect(result.ok).toBe(true);
+        const [, requestInit] = fetchMock.mock.calls[0] || [];
+        expect(JSON.parse(String(requestInit?.body))).toMatchObject({
+            workspaceId: 'ws-members',
+            workspaceMembers: [
+                expect.objectContaining({
+                    userId: 'user-1',
+                    email: 'member@example.com'
+                })
+            ]
+        });
     });
     it('returns single-endpoint status diagnostics on non-ok response', async () => {
         const fetchMock = vi.fn().mockResolvedValue({
             ok: false,
             status: 503,
-            json: () => Promise.resolve({ error: 'unavailable' })
+            text: () => Promise.resolve(JSON.stringify({ error: 'unavailable' }))
         });
         vi.stubGlobal('fetch', fetchMock);
         const result = await applyLocalWorkspaceChanges('ws-3', [{ op: 'upsert', archived: false, task: { id: 't-3' } }]);

package/dist/sync/index.d.ts

@@ -0,0 +1,2 @@
+export { encryptDocument, decryptDocument, ENCRYPTION_PREFIX } from './encryptionService.js';
+export { runWorkspacePushSyncService, ensureCloudWorkspaceReadyForSyncService, isTransientWorkspaceSyncStatus, } from './syncService.js';

package/dist/sync/index.js

@@ -0,0 +1,3 @@
+// Public API for the sync module
+export { encryptDocument, decryptDocument, ENCRYPTION_PREFIX } from './encryptionService.js';
+export { runWorkspacePushSyncService, ensureCloudWorkspaceReadyForSyncService, isTransientWorkspaceSyncStatus, } from './syncService.js';

package/dist/sync/syncService.d.ts

@@ -1,4 +1,5 @@
 import type { WorkspaceSyncPayload } from './workspaceSyncModel';
+export declare function isTransientWorkspaceSyncStatus(status: number | null | undefined): boolean;
 export interface EnsureWorkspaceReadyInput {
     cloudAuthConfigured: boolean;
     runtimeMode: 'local' | 'cloud';
@@ -15,6 +16,7 @@ export interface EnsureWorkspaceReadyResult {
     statusCode?: number;
     /** Milliseconds to wait before retrying, forwarded from a 429 Retry-After header. */
     retryAfterMs?: number;
+    transient?: boolean;
 }
 export declare function ensureCloudWorkspaceReadyForSyncService(input: EnsureWorkspaceReadyInput): Promise<EnsureWorkspaceReadyResult>;
 export interface UserSettingsSyncInput {
@@ -39,6 +41,7 @@ export interface WorkspacePushSyncInput {
     workspaceId: string;
     payload: WorkspaceSyncPayload;
     ensureCloudWorkspaceReadyForSync: () => Promise<EnsureWorkspaceReadyResult>;
+    repairMode?: boolean;
 }
 export interface WorkspacePushSyncResult {
     success: boolean;
@@ -46,15 +49,34 @@ export interface WorkspacePushSyncResult {
     error?: string;
     code?: string;
     retryAfterMs?: number;
+    transient?: boolean;
     syncedAt?: string;
     requestMs: number;
     changeCount: number;
     deleteCount: number;
     currentTaskIds: Set<string>;
     deleteTaskIds: Set<string>;
+    currentInitiativeIds: Set<string>;
+    currentInitiativeWatermarks: Map<string, string>;
+    currentWorkstreamIds: Set<string>;
+    currentWorkstreamWatermarks: Map<string, string>;
+    currentAiProfileIds: Set<string>;
+    currentAiProfileWatermarks: Map<string, string>;
     currentDocumentPaths: Set<string>;
     deleteDocumentPaths: Set<string>;
     currentDocumentWatermarks: Map<string, string>;
+    currentAssetPaths: Set<string>;
+    deleteAssetPaths: Set<string>;
+    currentAssetWatermarks: Map<string, string>;
+    currentDocumentReviewSessionIds: Set<string>;
+    deleteDocumentReviewSessionIds: Set<string>;
+    currentDocumentReviewSessionWatermarks: Map<string, string>;
+    currentDocumentReviewCommentIds: Set<string>;
+    deleteDocumentReviewCommentIds: Set<string>;
+    currentDocumentReviewCommentWatermarks: Map<string, string>;
+    currentAnnotatedAttachmentSessionIds: Set<string>;
+    deleteAnnotatedAttachmentSessionIds: Set<string>;
+    currentAnnotatedAttachmentSessionWatermarks: Map<string, string>;
     /** Watermarks for every task upsert that was successfully pushed. */
     pushedWatermarks: Map<string, string>;
     /** Server-emitted realtime mutation event ids for this push apply. */
@@ -71,12 +93,14 @@ export interface WorkspacePullSyncInput {
     maxPages?: number;
     onPagePulled?: () => void;
     onChangesApplied?: (count: number) => void;
+    repairMode?: boolean;
 }
 export interface WorkspacePullSyncResult {
     success: boolean;
     kind?: WorkspacePullFailureKind;
     status?: number;
     retryAfterMs?: number;
+    transient?: boolean;
     failures?: string[];
     hasTransientApplyFailure?: boolean;
     error?: string;
@@ -90,6 +114,7 @@ export interface WorkspacePullSyncResult {
     pulledActiveUpserts: boolean;
     pulledArchivedUpserts: boolean;
     documentDecryptFailures?: string[];
+    emittedEventIds?: string[];
 }
 export declare function runWorkspacePullSyncService(input: WorkspacePullSyncInput): Promise<WorkspacePullSyncResult>;
 export declare function syncUserGlobalSettingsService(input: UserSettingsSyncInput): Promise<UserSettingsSyncResult>;

package/dist/sync/syncService.js

@@ -3,6 +3,18 @@ import { encryptDocument, decryptDocument } from './encryptionService';
 function asObjectRecord(value) {
     return value && typeof value === 'object' ? value : {};
 }
+export function isTransientWorkspaceSyncStatus(status) {
+    const normalized = Number(status || 0);
+    return normalized === 0 || normalized === 429 || normalized >= 500;
+}
+function resolveWorkspaceAccessConflictMessage(data, fallbackStatus) {
+    const code = String(data.code || '').trim().toUpperCase();
+    const rawError = String(data.error || '').trim();
+    if (code === 'WORKSPACE_ID_ALREADY_EXISTS' || rawError.toLowerCase() === 'workspace id already exists') {
+        return 'This workspace is already linked to another cloud account. Sign in with the original account, ask the workspace owner to grant you access, or keep this workspace local-only.';
+    }
+    return rawError || `Workspace provisioning failed (${fallbackStatus})`;
+}
 export async function ensureCloudWorkspaceReadyForSyncService(input) {
     if (!input.cloudAuthConfigured)
         return { success: false, error: 'Cloud auth endpoint is not configured.' };
@@ -19,6 +31,7 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
             return {
                 success: false,
                 statusCode: 401,
+                transient: false,
                 error: String(data.error || 'Authentication required for workspace sync.')
             };
         }
@@ -27,6 +40,7 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
                 success: false,
                 statusCode: 429,
                 retryAfterMs: handshakeResult.retryAfterMs,
+                transient: true,
                 error: String(data.error || 'Workspace sync rate limited. Please retry later.')
             };
         }
@@ -40,21 +54,22 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
                 return {
                     success: false,
                     statusCode: provisionResult.status,
-                    error: String(provisionError.error || `Workspace provisioning failed (${provisionResult.status})`)
+                    error: resolveWorkspaceAccessConflictMessage(provisionError, provisionResult.status)
                 };
             }
             handshakeResult = await handshakeWorkspace(input.resolveCloudAuthUrl, input.workspaceId);
             if (!handshakeResult.ok) {
                 const retryData = asObjectRecord(handshakeResult.data);
                 if (handshakeResult.status === 401) {
-                    return { success: false, statusCode: 401, error: String(retryData.error || 'Authentication required for workspace sync.') };
+                    return { success: false, statusCode: 401, transient: false, error: String(retryData.error || 'Authentication required for workspace sync.') };
                 }
                 if (handshakeResult.status === 429) {
-                    return { success: false, statusCode: 429, retryAfterMs: handshakeResult.retryAfterMs, error: String(retryData.error || 'Workspace sync rate limited. Please retry later.') };
+                    return { success: false, statusCode: 429, retryAfterMs: handshakeResult.retryAfterMs, transient: true, error: String(retryData.error || 'Workspace sync rate limited. Please retry later.') };
                 }
                 return {
                     success: false,
                     statusCode: handshakeResult.status,
+                    transient: isTransientWorkspaceSyncStatus(handshakeResult.status),
                     error: String(retryData.error || `Workspace sync handshake failed (${handshakeResult.status})`)
                 };
             }
@@ -63,11 +78,12 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
         return {
             success: false,
             statusCode: handshakeResult.status,
+            transient: isTransientWorkspaceSyncStatus(handshakeResult.status),
             error: String(data.error || `Workspace sync handshake failed (${handshakeResult.status})`)
         };
     }
     catch {
-        return { success: false, error: 'Failed to validate workspace sync access.' };
+        return { success: false, statusCode: 0, transient: true, error: 'Failed to validate workspace sync access.' };
     }
 }
 async function computeIdempotencyKey(workspaceId, changes) {
@@ -106,6 +122,12 @@ export async function runWorkspacePushSyncService(input) {
                     content: await encryptDocument(change.content, syncKey)
                 });
             }
+            else if (change.op === 'asset-upsert' && typeof change.contentBase64 === 'string' && change.contentBase64.length > 0) {
+                encryptedChanges.push({
+                    ...change,
+                    contentBase64: await encryptDocument(change.contentBase64, syncKey)
+                });
+            }
             else {
                 encryptedChanges.push(change);
             }
@@ -117,7 +139,8 @@ export async function runWorkspacePushSyncService(input) {
         const result = await pushWorkspaceChanges(input.resolveCloudAuthUrl, {
             workspaceId: input.workspaceId,
             idempotencyKey,
-            changes: safeChanges
+            changes: safeChanges,
+            repairMode: input.repairMode === true
         });
         requestMs += (Date.now() - requestStartedAtMs);
         return result;
@@ -137,14 +160,33 @@ export async function runWorkspacePushSyncService(input) {
             error: typeof data.error === 'string' ? data.error : undefined,
             code: typeof data.code === 'string' ? data.code : undefined,
             retryAfterMs: pushResult.retryAfterMs,
+            transient: isTransientWorkspaceSyncStatus(pushResult.status),
             requestMs,
             changeCount,
             deleteCount,
             currentTaskIds: input.payload.currentTaskIds,
             deleteTaskIds: input.payload.deleteTaskIds,
+            currentInitiativeIds: input.payload.currentInitiativeIds,
+            currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
+            currentWorkstreamIds: input.payload.currentWorkstreamIds,
+            currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+            currentAiProfileIds: input.payload.currentAiProfileIds,
+            currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
             currentDocumentPaths: input.payload.currentDocumentPaths,
             deleteDocumentPaths: input.payload.deleteDocumentPaths,
             currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
+            currentAssetPaths: input.payload.currentAssetPaths,
+            deleteAssetPaths: input.payload.deleteAssetPaths,
+            currentAssetWatermarks: input.payload.currentAssetWatermarks,
+            currentDocumentReviewSessionIds: input.payload.currentDocumentReviewSessionIds,
+            deleteDocumentReviewSessionIds: input.payload.deleteDocumentReviewSessionIds,
+            currentDocumentReviewSessionWatermarks: input.payload.currentDocumentReviewSessionWatermarks,
+            currentDocumentReviewCommentIds: input.payload.currentDocumentReviewCommentIds,
+            deleteDocumentReviewCommentIds: input.payload.deleteDocumentReviewCommentIds,
+            currentDocumentReviewCommentWatermarks: input.payload.currentDocumentReviewCommentWatermarks,
+            currentAnnotatedAttachmentSessionIds: input.payload.currentAnnotatedAttachmentSessionIds,
+            deleteAnnotatedAttachmentSessionIds: input.payload.deleteAnnotatedAttachmentSessionIds,
+            currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
             pushedWatermarks: new Map(),
             emittedEventIds: []
         };
@@ -163,9 +205,27 @@ export async function runWorkspacePushSyncService(input) {
         deleteCount,
         currentTaskIds: input.payload.currentTaskIds,
         deleteTaskIds: input.payload.deleteTaskIds,
+        currentInitiativeIds: input.payload.currentInitiativeIds,
+        currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
+        currentWorkstreamIds: input.payload.currentWorkstreamIds,
+        currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
+        currentAiProfileIds: input.payload.currentAiProfileIds,
+        currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
         currentDocumentPaths: input.payload.currentDocumentPaths,
         deleteDocumentPaths: input.payload.deleteDocumentPaths,
         currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
+        currentAssetPaths: input.payload.currentAssetPaths,
+        deleteAssetPaths: input.payload.deleteAssetPaths,
+        currentAssetWatermarks: input.payload.currentAssetWatermarks,
+        currentDocumentReviewSessionIds: input.payload.currentDocumentReviewSessionIds,
+        deleteDocumentReviewSessionIds: input.payload.deleteDocumentReviewSessionIds,
+        currentDocumentReviewSessionWatermarks: input.payload.currentDocumentReviewSessionWatermarks,
+        currentDocumentReviewCommentIds: input.payload.currentDocumentReviewCommentIds,
+        deleteDocumentReviewCommentIds: input.payload.deleteDocumentReviewCommentIds,
+        currentDocumentReviewCommentWatermarks: input.payload.currentDocumentReviewCommentWatermarks,
+        currentAnnotatedAttachmentSessionIds: input.payload.currentAnnotatedAttachmentSessionIds,
+        deleteAnnotatedAttachmentSessionIds: input.payload.deleteAnnotatedAttachmentSessionIds,
+        currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
         pushedWatermarks: input.payload.pushedWatermarks,
         emittedEventIds
     };
@@ -181,6 +241,8 @@ export async function runWorkspacePullSyncService(input) {
     let pulledActiveUpserts = false;
     let pulledArchivedUpserts = false;
     const documentDecryptFailures = new Set();
+    const emittedEventIds = new Set();
+    const pulledAnnotatedAttachmentSessionIds = new Set();
     const maxPages = Number.isFinite(Number(input.maxPages)) ? Math.max(1, Math.floor(Number(input.maxPages))) : 20;
     try {
         while (hasMore && pages < maxPages) {
@@ -189,7 +251,8 @@ export async function runWorkspacePullSyncService(input) {
                 const result = await pullWorkspaceChanges(input.resolveCloudAuthUrl, {
                     workspaceId: input.workspaceId,
                     cursor,
-                    limit: input.bootstrap ? 500 : 200
+                    limit: input.bootstrap ? 500 : 200,
+                    repairMode: input.repairMode === true
                 });
                 pullRequestMs += (Date.now() - pullRequestStartedAtMs);
                 return result;
@@ -207,6 +270,7 @@ export async function runWorkspacePullSyncService(input) {
                     kind: 'pull_http',
                     status: pullRes.status,
                     retryAfterMs: pullRes.retryAfterMs,
+                    transient: isTransientWorkspaceSyncStatus(pullRes.status),
                     cursor,
                     pages,
                     appliedChanges,
@@ -220,6 +284,10 @@ export async function runWorkspacePullSyncService(input) {
             }
             const pullData = pullRes.data || {};
             const changes = Array.isArray(pullData?.changes) ? pullData.changes : [];
+            const hasWorkspaceMembersSnapshot = Array.isArray(pullData?.workspaceMembers);
+            const workspaceMembers = hasWorkspaceMembersSnapshot
+                ? pullData.workspaceMembers
+                : undefined;
             for (const change of changes) {
                 if (change.op === 'upsert') {
                     const isArchivedUpsert = change?.archived === true || change?.task?.isArchived === true;
@@ -229,6 +297,12 @@ export async function runWorkspacePullSyncService(input) {
                         pulledActiveUpserts = true;
                     continue;
                 }
+                if (change.op === 'annotated-attachment-session-upsert') {
+                    const sessionId = String(change?.session?.id || '').trim();
+                    if (sessionId)
+                        pulledAnnotatedAttachmentSessionIds.add(sessionId);
+                    continue;
+                }
                 if (change.op === 'document-upsert') {
                     if (typeof change.content === 'string' && typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
                         try {
@@ -243,6 +317,20 @@ export async function runWorkspacePullSyncService(input) {
                     }
                     continue;
                 }
+                if (change.op === 'asset-upsert') {
+                    if (typeof change.contentBase64 === 'string' && typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
+                        try {
+                            change.contentBase64 = await decryptDocument(change.contentBase64, process.env.TASKFORCE_SYNC_KEY);
+                        }
+                        catch {
+                            // Leave as-is on decrypt failure so the asset entry is not silently dropped.
+                            const path = String(change.path || '').trim();
+                            if (path)
+                                documentDecryptFailures.add(path);
+                        }
+                    }
+                    continue;
+                }
                 if (change.op !== 'delete')
                     continue;
                 const deleteTaskId = String(change.taskId || '').trim();
@@ -251,18 +339,23 @@ export async function runWorkspacePullSyncService(input) {
             }
             if (input.onPagePulled)
                 input.onPagePulled();
-            if (changes.length > 0) {
+            if (changes.length > 0 || hasWorkspaceMembersSnapshot) {
                 const applyStartedAtMs = Date.now();
-                const applyResult = await applyLocalWorkspaceChanges(input.workspaceId, changes);
+                const applyResult = await applyLocalWorkspaceChanges(input.workspaceId, changes, {
+                    ...(hasWorkspaceMembersSnapshot ? { workspaceMembers } : {}),
+                    repairMode: input.repairMode === true
+                });
                 const applyFailures = applyResult.failures;
                 if (!applyResult.ok) {
                     applyMs += (Date.now() - applyStartedAtMs);
+                    const applyPayloadData = asObjectRecord(applyResult.data);
                     const hasAuthFailure = applyFailures.some((entry) => entry.endsWith(':401'));
                     if (hasAuthFailure) {
                         return {
                             success: false,
                             kind: 'apply_auth',
                             status: 401,
+                            transient: false,
                             failures: applyFailures,
                             cursor,
                             pages,
@@ -285,6 +378,9 @@ export async function runWorkspacePullSyncService(input) {
                     return {
                         success: false,
                         kind: 'apply_all_candidates',
+                        status: applyResult.status || undefined,
+                        transient: hasTransientApplyFailure,
+                        error: String(applyPayloadData.error || '').trim() || undefined,
                         failures: applyFailures,
                         hasTransientApplyFailure,
                         cursor,
@@ -295,7 +391,8 @@ export async function runWorkspacePullSyncService(input) {
                         pulledDeleteTaskIds,
                         pulledActiveUpserts,
                         pulledArchivedUpserts,
-                        documentDecryptFailures: Array.from(documentDecryptFailures)
+                        documentDecryptFailures: Array.from(documentDecryptFailures),
+                        emittedEventIds: Array.from(emittedEventIds)
                     };
                 }
                 const applyPayloadData = asObjectRecord(applyResult.data);
@@ -304,6 +401,7 @@ export async function runWorkspacePullSyncService(input) {
                     return {
                         success: false,
                         kind: 'apply_payload',
+                        transient: false,
                         error: String(applyPayloadData.error || 'Workspace sync apply failed.'),
                         cursor,
                         pages,
@@ -313,11 +411,17 @@ export async function runWorkspacePullSyncService(input) {
                         pulledDeleteTaskIds,
                         pulledActiveUpserts,
                         pulledArchivedUpserts,
-                        documentDecryptFailures: Array.from(documentDecryptFailures)
+                        documentDecryptFailures: Array.from(documentDecryptFailures),
+                        emittedEventIds: Array.from(emittedEventIds)
                     };
                 }
                 applyMs += (Date.now() - applyStartedAtMs);
                 appliedChanges += changes.length;
+                if (Array.isArray(applyPayloadData.emittedEventIds)) {
+                    for (const eventId of applyPayloadData.emittedEventIds) {
+                        emittedEventIds.add(String(eventId));
+                    }
+                }
                 if (input.onChangesApplied)
                     input.onChangesApplied(changes.length);
             }
@@ -329,6 +433,66 @@ export async function runWorkspacePullSyncService(input) {
             hasMore = Boolean(pullData?.hasMore);
             pages += 1;
         }
+        if (input.bootstrap) {
+            const bootstrapApplyStartedAtMs = Date.now();
+            const bootstrapApplyResult = await applyLocalWorkspaceChanges(input.workspaceId, [], {
+                bootstrapSnapshot: {
+                    currentAnnotatedAttachmentSessionIds: Array.from(pulledAnnotatedAttachmentSessionIds),
+                }
+            });
+            const bootstrapApplyFailures = bootstrapApplyResult.failures;
+            if (!bootstrapApplyResult.ok) {
+                applyMs += (Date.now() - bootstrapApplyStartedAtMs);
+                const applyPayloadData = asObjectRecord(bootstrapApplyResult.data);
+                const hasAuthFailure = bootstrapApplyFailures.some((entry) => entry.endsWith(':401'));
+                if (hasAuthFailure) {
+                    return {
+                        success: false,
+                        kind: 'apply_auth',
+                        status: 401,
+                        transient: false,
+                        failures: bootstrapApplyFailures,
+                        cursor,
+                        pages,
+                        appliedChanges,
+                        pullRequestMs,
+                        applyMs,
+                        pulledDeleteTaskIds,
+                        pulledActiveUpserts,
+                        pulledArchivedUpserts,
+                        documentDecryptFailures: Array.from(documentDecryptFailures),
+                        emittedEventIds: Array.from(emittedEventIds)
+                    };
+                }
+                const hasTransientApplyFailure = bootstrapApplyFailures.some((entry) => {
+                    if (entry.endsWith(':network'))
+                        return true;
+                    const statusText = entry.split(':').pop() || '';
+                    const status = Number.parseInt(statusText, 10);
+                    return Number.isFinite(status) && (status === 429 || status >= 500);
+                });
+                return {
+                    success: false,
+                    kind: 'apply_all_candidates',
+                    status: bootstrapApplyResult.status || undefined,
+                    transient: hasTransientApplyFailure,
+                    error: String(applyPayloadData.error || '').trim() || undefined,
+                    failures: bootstrapApplyFailures,
+                    hasTransientApplyFailure,
+                    cursor,
+                    pages,
+                    appliedChanges,
+                    pullRequestMs,
+                    applyMs,
+                    pulledDeleteTaskIds,
+                    pulledActiveUpserts,
+                    pulledArchivedUpserts,
+                    documentDecryptFailures: Array.from(documentDecryptFailures),
+                    emittedEventIds: Array.from(emittedEventIds)
+                };
+            }
+            applyMs += (Date.now() - bootstrapApplyStartedAtMs);
+        }
         return {
             success: true,
             syncedAt: new Date().toISOString(),
@@ -340,13 +504,17 @@ export async function runWorkspacePullSyncService(input) {
             pulledDeleteTaskIds,
             pulledActiveUpserts,
             pulledArchivedUpserts,
-            documentDecryptFailures: Array.from(documentDecryptFailures)
+            documentDecryptFailures: Array.from(documentDecryptFailures),
+            emittedEventIds: Array.from(emittedEventIds)
         };
     }
-    catch {
+    catch (error) {
         return {
             success: false,
             kind: 'exception',
+            status: 0,
+            transient: true,
+            error: String(error?.message || error || 'Workspace sync pull failed unexpectedly.'),
             cursor: cursor || null,
             pages,
             appliedChanges,
@@ -355,12 +523,12 @@ export async function runWorkspacePullSyncService(input) {
             pulledDeleteTaskIds,
             pulledActiveUpserts,
             pulledArchivedUpserts,
-            documentDecryptFailures: Array.from(documentDecryptFailures)
+            documentDecryptFailures: Array.from(documentDecryptFailures),
+            emittedEventIds: Array.from(emittedEventIds)
         };
     }
 }
 export async function syncUserGlobalSettingsService(input) {
-    const isTransientStatus = (status) => status === 0 || status === 429 || status >= 500;
     const pullResult = await pullUserSettings(input.resolveCloudAuthUrl);
     if (!pullResult.ok) {
         const status = Number(pullResult.status || 0);
@@ -369,7 +537,7 @@ export async function syncUserGlobalSettingsService(input) {
             error: `Sync pull failed (${pullResult.status})`,
             statusCode: pullResult.status,
             retryAfterMs: pullResult.retryAfterMs,
-            transient: isTransientStatus(status)
+            transient: isTransientWorkspaceSyncStatus(status)
         };
     }
     const pullData = asObjectRecord(pullResult.data);
@@ -402,7 +570,7 @@ export async function syncUserGlobalSettingsService(input) {
             error: `Sync push failed (${pushResult.status})`,
             statusCode: pushResult.status,
             retryAfterMs: pushResult.retryAfterMs,
-            transient: isTransientStatus(status)
+            transient: isTransientWorkspaceSyncStatus(status)
         };
     }
     const pushData = asObjectRecord(pushResult.data);