@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/hooks/sync/transfers.js

@@ -1,582 +1,20 @@
-import { applyLocalWorkspaceChanges } from '../../sync/cloudSyncApi';
-import { isTransientWorkspaceSyncStatus, runWorkspacePullSyncService, runWorkspacePushSyncService } from '../../sync/syncService';
-import { createWorkspaceSyncLeaseHeldDecision, resolvePullSyncReadiness, resolvePushSyncReadiness } from './controlPlane';
-import { resolveWorkspacePullRequestPlan, resolveWorkspacePullSuccessPlan } from './pullLifecycle';
-import { logSyncDebug } from './orchestratorShared';
-export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtimeMode, workspaceCloudSyncEnabled, currentWorkspaceId, workspaceSyncPhase, isAuthenticated, checkAuthSession, resolveCloudAuthUrl, ensureCloudWorkspaceReadyForSync, ensureWorkspaceSyncReady, handleSyncAuthFailure, clearWorkspaceRetry, clearWorkspaceIssue, isWorkspaceRetryPending, scheduleWorkspaceSyncRetry, persistWorkspaceSyncPatchSafely, persistWorkspaceSyncPatchBestEffort, persistWorkspaceSyncWatermarksSnapshotBestEffort, reportSyncEvent, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, reportWorkspaceWindowContention, refreshWorkspaceSyncMarkdownDocumentsSnapshot, refreshWorkspaceSyncAiProfilesSnapshot, refreshWorkspaceSyncAssetsSnapshot, refreshWorkspaceSyncPlanningEntitiesSnapshot, refreshWorkspaceSyncDocumentReviewSessionsSnapshot, refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot, refreshLocalWorkspaceTaskCollections, buildWorkspaceSyncPayload, buildWorkspaceSyncSignature, seedWorkspaceSnapshotPushBaseline, shouldSuppressAttachBootstrapPush, recordSuppressedEventIds, workspaceRepairModeRef, workspaceForceFullAiProfilePushRef, workspacePushInFlightRef, workspacePullInFlightRef, workspacePendingPushReplayRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, workspaceLastPushedWatermarksRef, workspaceLastPushedTaskChangeKeysRef, workspaceLastPushedInitiativeIdsRef, workspaceLastPushedInitiativeWatermarksRef, workspaceLastPushedWorkstreamIdsRef, workspaceLastPushedWorkstreamWatermarksRef, workspaceLastPushedAiProfileIdsRef, workspaceLastPushedAiProfileWatermarksRef, workspaceLastPushedAiProfileChangeKeysRef, workspaceLastPushedDocumentPathsRef, workspaceLastPushedDocumentWatermarksRef, workspaceLastPushedAssetPathsRef, workspaceLastPushedAssetWatermarksRef, workspaceLastPushedDocumentReviewSessionIdsRef, workspaceLastPushedDocumentReviewSessionWatermarksRef, workspaceLastPushedDocumentReviewCommentIdsRef, workspaceLastPushedDocumentReviewCommentWatermarksRef, workspaceLastPushedAnnotatedAttachmentSessionIdsRef, workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, workspaceLastPushedTaskEventWatermarksRef, workspaceBaselineResetReasonRef, workspaceCaptureAttachBootstrapBaselineRef, workspaceStartupFullReconcileRanRef, workspaceFullReconcileInFlightRef, bootstrapLastProgressAtRef, realtimeSuppressedEventQueueRef, setWorkspaceSyncBusy, setUserGlobalSyncStatus, setUserGlobalSyncError, setWorkspaceLastErrorMessage, setWorkspaceLastErrorAt, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceSyncPendingChanges, setTasks, setArchivedTasks }) {
-    const pushWorkspaceChangesToCloud = async (signature, options) => {
-        let pushReadiness = resolvePushSyncReadiness({
-            cloudAuthConfigured,
-            runtimeMode,
-            workspaceCloudSyncEnabled,
-            currentWorkspaceId,
-            workspaceSyncPhase,
-            isAuthenticated,
-            repairModeActive: workspaceRepairModeRef.current === true,
-            repairModeBypass: options?.repairMode === true,
-            pushInFlight: workspacePushInFlightRef.current,
-            pullInFlight: workspacePullInFlightRef.current
-        });
-        if (!pushReadiness.allowed && pushReadiness.reason === 'auth-required') {
-            const authed = await checkAuthSession();
-            if (!authed)
-                return false;
-            pushReadiness = resolvePushSyncReadiness({
-                cloudAuthConfigured,
-                runtimeMode,
-                workspaceCloudSyncEnabled,
-                currentWorkspaceId,
-                workspaceSyncPhase,
-                isAuthenticated: true,
-                repairModeActive: workspaceRepairModeRef.current === true,
-                repairModeBypass: options?.repairMode === true,
-                pushInFlight: workspacePushInFlightRef.current,
-                pullInFlight: workspacePullInFlightRef.current
-            });
-        }
-        if (!pushReadiness.allowed) {
-            if (pushReadiness.retainPendingSignature) {
-                workspacePendingSignatureRef.current = signature;
-            }
-            return false;
-        }
-        if (shouldSuppressAttachBootstrapPush(signature)) {
-            return false;
-        }
-        const leaseAcquired = await acquireWorkspaceSyncLease(currentWorkspaceId, 'push');
-        if (!leaseAcquired) {
-            const leaseDecision = createWorkspaceSyncLeaseHeldDecision('push');
-            if (!leaseDecision.allowed && leaseDecision.retainPendingSignature) {
-                workspacePendingSignatureRef.current = signature;
-            }
-            reportWorkspaceWindowContention('push');
-            return false;
-        }
-        workspacePushInFlightRef.current = true;
-        setWorkspaceSyncBusy(true);
-        setUserGlobalSyncStatus('syncing');
-        setUserGlobalSyncError(null);
-        const pushStartedAtMs = Date.now();
-        const forceAllAiProfiles = options?.forceAllAiProfiles === true || workspaceForceFullAiProfilePushRef.current === true;
-        const repairMode = options?.repairMode === true || workspaceRepairModeRef.current === true;
-        let payloadForAttempt = null;
-        let replayedPayload = false;
-        let attemptSignature = signature;
-        try {
-            await refreshWorkspaceSyncMarkdownDocumentsSnapshot();
-            await refreshWorkspaceSyncAiProfilesSnapshot();
-            await refreshWorkspaceSyncAssetsSnapshot();
-            await refreshWorkspaceSyncPlanningEntitiesSnapshot();
-            await refreshWorkspaceSyncDocumentReviewSessionsSnapshot();
-            const ready = await ensureWorkspaceSyncReady();
-            if (!ready)
-                return false;
-            const refreshedSignature = buildWorkspaceSyncSignature();
-            if (refreshedSignature) {
-                attemptSignature = refreshedSignature;
-            }
-            if (shouldSuppressAttachBootstrapPush(attemptSignature)) {
-                return false;
-            }
-            const pendingReplay = workspacePendingPushReplayRef.current;
-            const canReplayPayload = (pendingReplay
-                && pendingReplay.signature === attemptSignature
-                && (!forceAllAiProfiles || pendingReplay.forceAllAiProfiles === true)
-                && (!repairMode || pendingReplay.repairMode === true));
-            const replayPayload = canReplayPayload
-                ? pendingReplay
-                : null;
-            const payload = replayPayload?.payload || buildWorkspaceSyncPayload({ forceAllAiProfiles });
-            payloadForAttempt = payload;
-            replayedPayload = replayPayload !== null;
-            setWorkspaceSyncPendingChanges(payload.changes.length);
-            const pushResult = await runWorkspacePushSyncService({
-                resolveCloudAuthUrl,
-                workspaceId: currentWorkspaceId,
-                payload,
-                ensureCloudWorkspaceReadyForSync,
-                repairMode: replayPayload?.repairMode ?? repairMode
-            });
-            if (!pushResult.success) {
-                if (pushResult.status === 401) {
-                    workspacePendingPushReplayRef.current = null;
-                    await handleSyncAuthFailure('push', 401);
-                    return false;
-                }
-                let message = pushResult.error
-                    ? `Workspace sync push failed (${pushResult.status || 0}): ${pushResult.error}`
-                    : `Workspace sync push failed (${pushResult.status || 0})`;
-                if (pushResult.status === 413) {
-                    message = 'Workspace sync failed because the payload is too large. This usually happens when one or more attachments exceed the project limit.';
-                }
-                setUserGlobalSyncStatus('error');
-                setUserGlobalSyncError(message);
-                setWorkspaceLastErrorMessage(message);
-                setWorkspaceLastErrorAt(new Date().toISOString());
-                reportSyncEvent(currentWorkspaceId, {
-                    eventType: 'push',
-                    status: 'error',
-                    statusCode: pushResult.status,
-                    errorMessage: message,
-                    requestMs: pushResult.requestMs,
-                    details: {
-                        payloadDiagnostics: payload.deltaDiagnostics || null,
-                        replayedPayload
-                    }
-                });
-                workspacePendingSignatureRef.current = attemptSignature;
-                if (pushResult.transient || isTransientWorkspaceSyncStatus(pushResult.status)) {
-                    workspacePendingPushReplayRef.current = {
-                        signature: attemptSignature,
-                        payload,
-                        forceAllAiProfiles: replayPayload?.forceAllAiProfiles ?? forceAllAiProfiles,
-                        repairMode: replayPayload?.repairMode ?? repairMode
-                    };
-                    scheduleWorkspaceSyncRetry(pushResult.retryAfterMs);
-                }
-                else {
-                    workspacePendingPushReplayRef.current = null;
-                    if (workspaceSyncPhase === 'active') {
-                        persistWorkspaceSyncPatchSafely({ phase: 'error', lastErrorMessage: message });
-                    }
-                }
-                return false;
-            }
-            workspacePendingPushReplayRef.current = null;
-            workspaceLastPushedSignatureRef.current = attemptSignature;
-            workspaceLastPushedTaskIdsRef.current = pushResult.currentTaskIds;
-            workspaceLastPushedWatermarksRef.current = pushResult.currentTaskWatermarks
-                ? new Map(pushResult.currentTaskWatermarks)
-                : new Map(workspaceLastPushedWatermarksRef.current);
-            workspaceLastPushedTaskChangeKeysRef.current = pushResult.currentTaskChangeKeys
-                ? new Map(pushResult.currentTaskChangeKeys)
-                : new Map(workspaceLastPushedTaskChangeKeysRef.current);
-            workspaceLastPushedInitiativeIdsRef.current = new Set(pushResult.currentInitiativeIds);
-            workspaceLastPushedInitiativeWatermarksRef.current = new Map(pushResult.currentInitiativeWatermarks);
-            workspaceLastPushedWorkstreamIdsRef.current = new Set(pushResult.currentWorkstreamIds);
-            workspaceLastPushedWorkstreamWatermarksRef.current = new Map(pushResult.currentWorkstreamWatermarks);
-            workspaceLastPushedAiProfileIdsRef.current = new Set(pushResult.currentAiProfileIds);
-            workspaceLastPushedAiProfileWatermarksRef.current = new Map(pushResult.currentAiProfileWatermarks);
-            workspaceLastPushedAiProfileChangeKeysRef.current = pushResult.currentAiProfileChangeKeys
-                ? new Map(pushResult.currentAiProfileChangeKeys)
-                : new Map(workspaceLastPushedAiProfileChangeKeysRef.current);
-            workspaceLastPushedDocumentPathsRef.current = new Set(pushResult.currentDocumentPaths);
-            workspaceLastPushedDocumentWatermarksRef.current = new Map(pushResult.currentDocumentWatermarks);
-            workspaceLastPushedAssetPathsRef.current = new Set(pushResult.currentAssetPaths);
-            workspaceLastPushedAssetWatermarksRef.current = new Map(pushResult.currentAssetWatermarks);
-            workspaceLastPushedDocumentReviewSessionIdsRef.current = new Set(pushResult.currentDocumentReviewSessionIds);
-            workspaceLastPushedDocumentReviewSessionWatermarksRef.current = new Map(pushResult.currentDocumentReviewSessionWatermarks);
-            workspaceLastPushedDocumentReviewCommentIdsRef.current = new Set(pushResult.currentDocumentReviewCommentIds);
-            workspaceLastPushedDocumentReviewCommentWatermarksRef.current = new Map(pushResult.currentDocumentReviewCommentWatermarks);
-            workspaceLastPushedAnnotatedAttachmentSessionIdsRef.current = new Set(pushResult.currentAnnotatedAttachmentSessionIds);
-            workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef.current = new Map(pushResult.currentAnnotatedAttachmentSessionWatermarks);
-            workspaceLastPushedTaskEventWatermarksRef.current = new Map(pushResult.currentTaskEventWatermarks);
-            if (forceAllAiProfiles) {
-                workspaceForceFullAiProfilePushRef.current = false;
-            }
-            for (const [taskId, watermark] of pushResult.pushedWatermarks) {
-                workspaceLastPushedWatermarksRef.current.set(taskId, watermark);
-            }
-            for (const [taskId, changeKey] of (pushResult.pushedTaskChangeKeys || new Map())) {
-                workspaceLastPushedTaskChangeKeysRef.current.set(taskId, changeKey);
-            }
-            if (pushResult.deleteTaskIds.size > 0) {
-                for (const taskId of pushResult.deleteTaskIds) {
-                    workspaceDeletedTaskIdsRef.current.delete(taskId);
-                    workspaceDeletedTaskWatermarksRef.current.delete(taskId);
-                    workspaceLastPushedWatermarksRef.current.delete(taskId);
-                    workspaceLastPushedTaskChangeKeysRef.current.delete(taskId);
-                }
-            }
-            const persisted = await persistWorkspaceSyncWatermarksSnapshotBestEffort();
-            workspaceBaselineResetReasonRef.current = persisted ? null : 'storage-write-failed';
-            if (Array.isArray(pushResult.emittedEventIds) && pushResult.emittedEventIds.length > 0) {
-                recordSuppressedEventIds(pushResult.emittedEventIds, {
-                    queueRef: realtimeSuppressedEventQueueRef,
-                    maxQueueSize: 2048
-                });
-            }
-            if (Array.isArray(pushResult.appliedTaskUpserts) && pushResult.appliedTaskUpserts.length > 0) {
-                const applyResult = await applyLocalWorkspaceChanges(currentWorkspaceId, pushResult.appliedTaskUpserts.map((entry) => ({
-                    op: 'upsert',
-                    archived: entry.archived === true,
-                    task: entry.task
-                })));
-                if (applyResult.ok) {
-                    for (const entry of pushResult.appliedTaskUpserts) {
-                        const taskId = String(entry?.task?.id || '').trim();
-                        const watermark = String(entry?.task?.updatedAt || entry?.task?.createdAt || '').trim();
-                        if (!taskId || !watermark)
-                            continue;
-                        workspaceLastPushedWatermarksRef.current.set(taskId, watermark);
-                    }
-                    try {
-                        await refreshLocalWorkspaceTaskCollections();
-                    }
-                    catch {
-                        logSyncDebug('push_local_task_refresh_failed', {
-                            workspaceId: currentWorkspaceId,
-                            taskCount: pushResult.appliedTaskUpserts.length
-                        });
-                    }
-                }
-                else {
-                    logSyncDebug('push_local_task_apply_failed', {
-                        workspaceId: currentWorkspaceId,
-                        taskCount: pushResult.appliedTaskUpserts.length,
-                        status: applyResult.status,
-                        failures: applyResult.failures
-                    });
-                }
-            }
-            clearWorkspaceRetry();
-            clearWorkspaceIssue();
-            const syncedAt = pushResult.syncedAt || new Date().toISOString();
-            workspaceLastPushedSignatureRef.current = buildWorkspaceSyncSignature();
-            setWorkspaceLastPushAt(syncedAt);
-            setWorkspaceSyncPendingChanges(0);
-            setUserGlobalSyncStatus('idle');
-            persistWorkspaceSyncPatchSafely({
-                phase: 'active',
-                lastPushAt: syncedAt,
-                lastSyncedAt: syncedAt,
-                lastErrorMessage: null
-            });
-            reportSyncEvent(currentWorkspaceId, {
-                eventType: workspaceSyncPhase === 'provision-local' ? 'bootstrap' : 'push',
-                status: 'success',
-                changeCount: pushResult.changeCount,
-                requestMs: pushResult.requestMs,
-                details: {
-                    payloadDiagnostics: payload.deltaDiagnostics || null,
-                    replayedPayload
-                }
-            });
-            return true;
-        }
-        catch (error) {
-            const message = 'Workspace sync push failed.';
-            setUserGlobalSyncStatus('error');
-            setUserGlobalSyncError(message);
-            setWorkspaceLastErrorMessage(message);
-            setWorkspaceLastErrorAt(new Date().toISOString());
-            workspacePendingSignatureRef.current = attemptSignature;
-            if (payloadForAttempt) {
-                workspacePendingPushReplayRef.current = {
-                    signature: attemptSignature,
-                    payload: payloadForAttempt,
-                    forceAllAiProfiles,
-                    repairMode
-                };
-            }
-            scheduleWorkspaceSyncRetry();
-            reportSyncEvent(currentWorkspaceId, {
-                eventType: 'push',
-                status: 'error',
-                errorMessage: `${message} ${String(error?.message || '').trim()}`.trim(),
-                details: {
-                    replayedPayload
-                }
-            });
-            logSyncDebug('push_failed_exception', {
-                workspaceId: currentWorkspaceId,
-                elapsedMs: Date.now() - pushStartedAtMs
-            });
-            return false;
-        }
-        finally {
-            workspacePushInFlightRef.current = false;
-            setWorkspaceSyncBusy(workspacePullInFlightRef.current);
-            releaseWorkspaceSyncLease(currentWorkspaceId);
-            const pendingSignature = workspacePendingSignatureRef.current;
-            const latestSignature = buildWorkspaceSyncSignature();
-            if (pendingSignature
-                && latestSignature
-                && latestSignature !== workspaceLastPushedSignatureRef.current
-                && !workspacePullInFlightRef.current
-                && !isWorkspaceRetryPending()) {
-                workspacePendingSignatureRef.current = '';
-                window.setTimeout(() => {
-                    void pushWorkspaceChangesToCloud(latestSignature);
-                }, 120);
-            }
-        }
-    };
-    const pullWorkspaceChangesFromCloud = async (options) => {
-        let pullReadiness = resolvePullSyncReadiness({
-            cloudAuthConfigured,
-            runtimeMode,
-            workspaceCloudSyncEnabled,
-            currentWorkspaceId,
-            workspaceSyncPhase,
-            isAuthenticated,
-            repairModeActive: workspaceRepairModeRef.current === true,
-            repairModeBypass: options?.repairMode === true,
-            retryPending: isWorkspaceRetryPending(),
-            pullInFlight: workspacePullInFlightRef.current,
-            pushInFlight: workspacePushInFlightRef.current
-        });
-        if (!pullReadiness.allowed && pullReadiness.reason === 'auth-required') {
-            const authed = await checkAuthSession();
-            if (!authed)
-                return false;
-            pullReadiness = resolvePullSyncReadiness({
-                cloudAuthConfigured,
-                runtimeMode,
-                workspaceCloudSyncEnabled,
-                currentWorkspaceId,
-                workspaceSyncPhase,
-                isAuthenticated: true,
-                repairModeActive: workspaceRepairModeRef.current === true,
-                repairModeBypass: options?.repairMode === true,
-                retryPending: isWorkspaceRetryPending(),
-                pullInFlight: workspacePullInFlightRef.current,
-                pushInFlight: workspacePushInFlightRef.current
-            });
-        }
-        if (!pullReadiness.allowed) {
-            return false;
-        }
-        const leaseAcquired = await acquireWorkspaceSyncLease(currentWorkspaceId, 'pull');
-        if (!leaseAcquired) {
-            reportWorkspaceWindowContention('pull');
-            return false;
-        }
-        workspacePullInFlightRef.current = true;
-        setWorkspaceSyncBusy(true);
-        setUserGlobalSyncStatus('syncing');
-        setUserGlobalSyncError(null);
-        const pullStartedAtMs = Date.now();
-        try {
-            const ready = await ensureWorkspaceSyncReady();
-            if (!ready)
-                return false;
-            const pullRequestPlan = resolveWorkspacePullRequestPlan({
-                workspaceSyncPhase,
-                forceCursorNull: options?.forceCursorNull === true,
-                currentCursor: workspacePullCursorRef.current
-            });
-            const pullResult = await runWorkspacePullSyncService({
-                resolveCloudAuthUrl,
-                workspaceId: currentWorkspaceId,
-                cursor: pullRequestPlan.cursor,
-                bootstrap: pullRequestPlan.bootstrap,
-                ensureCloudWorkspaceReadyForSync,
-                maxPages: 20,
-                repairMode: options?.repairMode === true || workspaceRepairModeRef.current === true,
-                onPagePulled: () => { bootstrapLastProgressAtRef.current = Date.now(); },
-                onChangesApplied: () => { bootstrapLastProgressAtRef.current = Date.now(); }
-            });
-            if (!pullResult.success) {
-                if (pullResult.kind === 'pull_http' && pullResult.status === 401) {
-                    await handleSyncAuthFailure('pull', 401);
-                    return false;
-                }
-                if (pullResult.kind === 'apply_auth') {
-                    await handleSyncAuthFailure('apply', 401);
-                    return false;
-                }
-                if (pullResult.kind === 'pull_http' && pullResult.errorCode === 'INVALID_SYNC_CURSOR') {
-                    const message = 'Saved sync cursor was invalid. Clearing it and retrying from the beginning.';
-                    workspacePullCursorRef.current = null;
-                    persistWorkspaceSyncPatchSafely({ pullCursor: null });
-                    setUserGlobalSyncStatus('error');
-                    setUserGlobalSyncError(message);
-                    setWorkspaceLastErrorMessage(message);
-                    setWorkspaceLastErrorAt(new Date().toISOString());
-                    reportSyncEvent(currentWorkspaceId, {
-                        eventType: 'pull',
-                        status: 'error',
-                        statusCode: pullResult.status,
-                        errorMessage: message,
-                        requestMs: pullResult.pullRequestMs,
-                        details: {
-                            recovery: 'cursor-reset',
-                            ...(pullResult.serverDiagnostics ? { serverPullDiagnostics: pullResult.serverDiagnostics } : {})
-                        }
-                    });
-                    scheduleWorkspaceSyncRetry(150);
-                    return false;
-                }
-                let message = pullResult.kind === 'apply_payload' || pullResult.kind === 'apply_all_candidates' || pullResult.kind === 'exception'
-                    ? String(pullResult.error || 'Workspace sync apply failed.')
-                    : `Workspace sync pull failed (${pullResult.status || 0})`;
-                if (pullResult.status === 413) {
-                    message = 'Local sync failed because the downloaded payload is too large. This usually happens when the workspace contains massive attachments.';
-                }
-                setUserGlobalSyncStatus('error');
-                setUserGlobalSyncError(message);
-                setWorkspaceLastErrorMessage(message);
-                setWorkspaceLastErrorAt(new Date().toISOString());
-                reportSyncEvent(currentWorkspaceId, {
-                    eventType: pullResult.kind?.startsWith('apply') ? 'apply' : 'pull',
-                    status: 'error',
-                    statusCode: pullResult.status,
-                    errorMessage: message,
-                    requestMs: pullResult.pullRequestMs,
-                    details: {
-                        pages: pullResult.pages,
-                        applyMs: pullResult.applyMs,
-                        ...(pullResult.serverDiagnostics ? { serverPullDiagnostics: pullResult.serverDiagnostics } : {})
-                    }
-                });
-                if (pullResult.transient || pullResult.hasTransientApplyFailure || isTransientWorkspaceSyncStatus(pullResult.status)) {
-                    scheduleWorkspaceSyncRetry(pullResult.retryAfterMs);
-                }
-                else {
-                    persistWorkspaceSyncPatchSafely({ phase: 'error', lastErrorMessage: message });
-                }
-                return false;
-            }
-            if (Array.isArray(pullResult.emittedEventIds)) {
-                recordSuppressedEventIds(pullResult.emittedEventIds, { ttlMs: 60_000 });
-            }
-            if (pullResult.pulledDeleteTaskIds.size > 0) {
-                setTasks((prev) => prev.filter((task) => !pullResult.pulledDeleteTaskIds.has(String(task.id || ''))));
-                setArchivedTasks((prev) => prev.filter((task) => !pullResult.pulledDeleteTaskIds.has(String(task.id || ''))));
-            }
-            const decryptFailures = Array.isArray(pullResult.documentDecryptFailures)
-                ? pullResult.documentDecryptFailures.filter((value) => String(value || '').trim().length > 0)
-                : [];
-            if (decryptFailures.length > 0) {
-                logSyncDebug('pull_document_decrypt_failures', {
-                    workspaceId: currentWorkspaceId,
-                    failureCount: decryptFailures.length
-                });
-            }
-            workspacePullCursorRef.current = pullResult.cursor || null;
-            if (pullResult.appliedChanges > 0
-                && (pullResult.pulledActiveUpserts
-                    || pullResult.pulledArchivedUpserts
-                    || pullResult.pulledTaskEventUpserts
-                    || pullResult.pulledPlanningUpserts)) {
-                try {
-                    await refreshLocalWorkspaceTaskCollections();
-                }
-                catch {
-                    logSyncDebug('pull_local_refresh_failed', {
-                        workspaceId: currentWorkspaceId,
-                        appliedChanges: pullResult.appliedChanges
-                    });
-                }
-            }
-            clearWorkspaceRetry();
-            clearWorkspaceIssue();
-            const syncedAt = pullResult.syncedAt || new Date().toISOString();
-            setWorkspaceLastPullAt(syncedAt);
-            setWorkspaceSyncPendingChanges(0);
-            setUserGlobalSyncStatus('idle');
-            const pullSuccessPlan = resolveWorkspacePullSuccessPlan({
-                workspaceSyncPhase,
-                forceCursorNull: options?.forceCursorNull === true,
-                startupFullReconcileRan: workspaceStartupFullReconcileRanRef.current,
-                pendingSignature: workspacePendingSignatureRef.current,
-                fallbackSignature: buildWorkspaceSyncSignature(),
-                lastPushedSignature: workspaceLastPushedSignatureRef.current
-            });
-            if (pullSuccessPlan.shouldCaptureAttachBootstrapBaseline) {
-                workspaceCaptureAttachBootstrapBaselineRef.current = true;
-            }
-            if (pullSuccessPlan.shouldClearPendingSignature) {
-                workspacePendingSignatureRef.current = '';
-                workspacePendingPushReplayRef.current = null;
-            }
-            await persistWorkspaceSyncPatchBestEffort({
-                phase: 'active',
-                pullCursor: workspacePullCursorRef.current,
-                lastPullAt: syncedAt,
-                lastSyncedAt: syncedAt,
-                ...(options?.forceCursorNull === true
-                    ? { startupFullReconcileCompletedAt: syncedAt }
-                    : {}),
-                lastErrorMessage: null
-            });
-            reportSyncEvent(currentWorkspaceId, {
-                eventType: pullSuccessPlan.successEventType,
-                status: 'success',
-                changeCount: pullResult.appliedChanges,
-                requestMs: pullResult.pullRequestMs,
-                details: {
-                    pages: pullResult.pages,
-                    applyMs: pullResult.applyMs,
-                    ...(pullResult.serverDiagnostics ? { serverPullDiagnostics: pullResult.serverDiagnostics } : {})
-                }
-            });
-            if (pullSuccessPlan.shouldRefreshReferenceSnapshots) {
-                await refreshWorkspaceSyncMarkdownDocumentsSnapshot();
-                await refreshWorkspaceSyncAssetsSnapshot();
-                await refreshWorkspaceSyncDocumentReviewSessionsSnapshot();
-                await refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot();
-            }
-            if (pullSuccessPlan.shouldSeedWorkspaceSnapshotPushBaseline) {
-                seedWorkspaceSnapshotPushBaseline();
-            }
-            if (pullSuccessPlan.shouldRefreshReferenceSnapshots || pullSuccessPlan.shouldSeedWorkspaceSnapshotPushBaseline) {
-                return true;
-            }
-            if (pullSuccessPlan.shouldScheduleStartupFullReconcile) {
-                workspaceStartupFullReconcileRanRef.current = true;
-                window.setTimeout(() => {
-                    if (workspaceFullReconcileInFlightRef.current)
-                        return;
-                    workspaceFullReconcileInFlightRef.current = true;
-                    void pullWorkspaceChangesFromCloud({ forceCursorNull: true }).finally(() => {
-                        workspaceFullReconcileInFlightRef.current = false;
-                    });
-                }, 250);
-            }
-            const shouldReassertAiProfilesAfterFullReconcile = (options?.forceCursorNull === true
-                && options?.repairMode !== true
-                && workspaceSyncPhase === 'active');
-            if (shouldReassertAiProfilesAfterFullReconcile) {
-                const reassertSignature = buildWorkspaceSyncSignature();
-                if (reassertSignature) {
-                    workspaceForceFullAiProfilePushRef.current = true;
-                    workspacePendingSignatureRef.current = reassertSignature;
-                    window.setTimeout(() => {
-                        void pushWorkspaceChangesToCloud(reassertSignature, { forceAllAiProfiles: true });
-                    }, 120);
-                }
-            }
-            else if (pullSuccessPlan.deferredPushSignature) {
-                const deferredPushSignature = pullSuccessPlan.deferredPushSignature;
-                window.setTimeout(() => {
-                    void pushWorkspaceChangesToCloud(deferredPushSignature);
-                }, 120);
-            }
-            return true;
-        }
-        catch (error) {
-            const detail = String(error?.message || '').trim();
-            const message = detail
-                ? `Workspace sync pull failed. ${detail}`
-                : 'Workspace sync pull failed.';
-            setUserGlobalSyncStatus('error');
-            setUserGlobalSyncError(message);
-            setWorkspaceLastErrorMessage(message);
-            setWorkspaceLastErrorAt(new Date().toISOString());
-            scheduleWorkspaceSyncRetry();
-            reportSyncEvent(currentWorkspaceId, {
-                eventType: 'pull',
-                status: 'error',
-                errorMessage: message,
-                requestMs: Date.now() - pullStartedAtMs
-            });
-            logSyncDebug('pull_failed_exception', {
-                workspaceId: currentWorkspaceId,
-                elapsedMs: Date.now() - pullStartedAtMs,
-                error: detail || null
-            });
-            return false;
-        }
-        finally {
-            workspacePullInFlightRef.current = false;
-            setWorkspaceSyncBusy(workspacePushInFlightRef.current);
-            releaseWorkspaceSyncLease(currentWorkspaceId);
-        }
-    };
-    return {
-        pushWorkspaceChangesToCloud,
-        pullWorkspaceChangesFromCloud
-    };
+import { dispatchTaskforceAiProfilesMutated } from '../../utils/aiProfileEvents.js';
+import { dispatchTaskforceAgentsMutated } from '../../utils/taskforceAgentEvents.js';
+import { dispatchTaskforceAgentSkillsMutated } from '../../utils/taskforceAgentSkillEvents.js';
+import { logSyncDebug } from './orchestratorShared.js';
+import { createWorkspaceTransferCoordinator as createEngineWorkspaceTransferCoordinator, } from '../../sync/engine/workspaceSyncEngineTransfers.js';
+export * from '../../sync/engine/workspaceSyncEngineTransfers.js';
+export function createWorkspaceTransferCoordinator(args) {
+    return createEngineWorkspaceTransferCoordinator({
+        now: () => new Date(),
+        scheduleTask: (callback, delayMs) => {
+            const timeoutId = window.setTimeout(callback, delayMs);
+            return { cancel: () => window.clearTimeout(timeoutId) };
+        },
+        logDebug: logSyncDebug,
+        notifyAiProfilesMutated: dispatchTaskforceAiProfilesMutated,
+        notifyAgentsMutated: dispatchTaskforceAgentsMutated,
+        notifyAgentSkillsMutated: dispatchTaskforceAgentSkillsMutated,
+        ...args,
+    });
 }

package/dist/hooks/sync/useDataVersionRefresh.d.ts

@@ -1,5 +1,6 @@
 import { type MutableRefObject } from 'react';
 interface UseDataVersionRefreshArgs {
+    workspaceId: string;
     isOpen: boolean;
     authBlocked: boolean;
     authRequiredForApi: boolean;
@@ -11,6 +12,10 @@ interface UseDataVersionRefreshArgs {
     isAuthenticatedRef: MutableRefObject<boolean>;
     dataVersionRef: MutableRefObject<number | null>;
     refreshTaskCollectionsForDataVersion: () => Promise<void>;
+    coordinatorDataVersion?: {
+        coordinatorGeneration: number;
+        localDataVersion: number;
+    } | null;
 }
-export declare function useDataVersionRefresh({ isOpen, authBlocked, authRequiredForApi, isAuthenticated, canCallProtectedApi, shouldGateProtectedApiCalls, authSessionResolvedRef, authRequiredForApiRef, isAuthenticatedRef, dataVersionRef, refreshTaskCollectionsForDataVersion }: UseDataVersionRefreshArgs): void;
+export declare function useDataVersionRefresh({ workspaceId, isOpen, authBlocked, authRequiredForApi, isAuthenticated, canCallProtectedApi, shouldGateProtectedApiCalls, authSessionResolvedRef, authRequiredForApiRef, isAuthenticatedRef, dataVersionRef, refreshTaskCollectionsForDataVersion, coordinatorDataVersion, }: UseDataVersionRefreshArgs): void;
 export {};