@taskforcehq/taskforce 0.3.303 → 0.3.304

package/dist/server/routes/billing.test.js

@@ -211,6 +211,18 @@ function setupBillingSchema(db) {
 function buildBillingRouteHandlers(db, opts) {
     const routes = new Map();
     const tenantId = 'default';
+    const resolvePlanIdForVersion = (planVersionIdRaw) => {
+        const planVersionId = String(planVersionIdRaw || '').trim();
+        if (!planVersionId)
+            return '';
+        const row = db.prepare(`
+            SELECT plan_id
+            FROM plan_versions
+            WHERE tenant_id = ? AND plan_version_id = ?
+            LIMIT 1
+        `).get(tenantId, planVersionId);
+        return String(row?.plan_id || '').trim();
+    };
     const core = {
         getDatabaseAdapter: () => db,
         getTenantId: () => tenantId,
@@ -223,6 +235,37 @@ function buildBillingRouteHandlers(db, opts) {
                 ON CONFLICT (user_id) DO NOTHING
             `).run(userId, tenantId, now, now);
         },
+        transitionCanonicalCommercialState: (input) => {
+            const now = new Date().toISOString();
+            const planVersionId = String(input.planVersionId || '').trim();
+            const effectiveAt = input.effectiveAt || now;
+            const effectiveUntil = input.effectiveUntil || null;
+            db.prepare(`
+                INSERT INTO account_entitlements (
+                    account_id, tenant_id, plan_version_id, entitlement_state, effective_at, effective_until, updated_by, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT (account_id) DO UPDATE SET
+                    plan_version_id = excluded.plan_version_id,
+                    entitlement_state = excluded.entitlement_state,
+                    effective_at = excluded.effective_at,
+                    effective_until = excluded.effective_until,
+                    updated_by = excluded.updated_by,
+                    updated_at = excluded.updated_at
+            `).run(input.accountId, tenantId, planVersionId, input.state, effectiveAt, effectiveUntil, input.updatedBy, input.createdAt || now, input.updatedAt || now);
+            const planId = typeof input.billingMirrorPlanId === 'string'
+                ? input.billingMirrorPlanId
+                : resolvePlanIdForVersion(planVersionId);
+            db.prepare(`
+                INSERT INTO user_billing (
+                    user_id, tenant_id, tier, entitlement_state, effective_until, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT (user_id) DO UPDATE SET
+                    tier = excluded.tier,
+                    entitlement_state = excluded.entitlement_state,
+                    effective_until = excluded.effective_until,
+                    updated_at = excluded.updated_at
+            `).run(input.accountId, tenantId, planId, input.state, effectiveUntil, now, now);
+        },
         listPlanCatalog: () => [
             { planId: 'pro', displayName: 'Pro Plan', status: 'active', createdAt: '', updatedAt: '' },
             { planId: 'inactive-plan', displayName: 'Inactive', status: 'archived', createdAt: '', updatedAt: '' },

package/dist/server/routes/shared.d.ts

@@ -7,8 +7,38 @@
  */
 import { IncomingMessage, ServerResponse } from 'http';
 import { TaskforceCore } from '../../core/Taskforce.js';
+import type { McpAccessTokenAuthResult, McpOAuthAccessTokenAuthResult, McpAccessTokenScope } from '../../core/Taskforce.js';
 import type { RouteContext } from '../routes.js';
+import type { AiProfileBootstrapConfig } from '../../mcp/aiProfileBootstrap.js';
 export declare function resolveErrorStatusCode(error: unknown, fallback?: number): number;
+export declare function buildCloudMcpRuntimeAuth(input: {
+    req: IncomingMessage;
+    auth: {
+        authenticatedViaToken: McpAccessTokenAuthResult | null;
+        authenticatedViaOAuth: McpOAuthAccessTokenAuthResult | null;
+        userId: string | null;
+    } & Required<AiProfileBootstrapConfig>;
+    requestHeader: (req: IncomingMessage, name: string, fallback?: string) => string;
+    requestId?: string | null;
+    authScopes?: McpAccessTokenScope[] | null;
+}): {
+    scopes?: McpAccessTokenScope[] | null;
+    userId?: string | null;
+    tokenId?: string | null;
+    aiProfileToken?: AiProfileBootstrapConfig['aiProfileToken'];
+    aiProfileName?: AiProfileBootstrapConfig['aiProfileName'];
+    aiProfileIcon?: AiProfileBootstrapConfig['aiProfileIcon'];
+    aiProfileColor?: AiProfileBootstrapConfig['aiProfileColor'];
+    aiProfileDescription?: AiProfileBootstrapConfig['aiProfileDescription'];
+    aiProfileRole?: AiProfileBootstrapConfig['aiProfileRole'];
+    aiProfileProvider?: AiProfileBootstrapConfig['aiProfileProvider'];
+    aiProfileModel?: AiProfileBootstrapConfig['aiProfileModel'];
+    aiProfileSurfaceType?: AiProfileBootstrapConfig['aiProfileSurfaceType'];
+    actorType?: 'local' | 'user' | 'token' | 'oauth';
+    requestId?: string | null;
+    ip?: string | null;
+    userAgent?: string | null;
+};
 export declare function requestHeader(req: IncomingMessage, name: string, fallback?: string): string;
 export declare function requestWorkspaceHeader(req: IncomingMessage): string;
 export declare function requestAuthoritativeWorkspaceId(req: IncomingMessage): string;

package/dist/server/routes/shared.js

@@ -17,6 +17,32 @@ export function resolveErrorStatusCode(error, fallback = 400) {
     }
     return fallback;
 }
+export function buildCloudMcpRuntimeAuth(input) {
+    const { req, auth, requestHeader, requestId, authScopes } = input;
+    const actorType = auth.authenticatedViaToken
+        ? 'token'
+        : auth.authenticatedViaOAuth
+            ? 'oauth'
+            : 'user';
+    return {
+        scopes: authScopes || auth.authenticatedViaToken?.scopes || auth.authenticatedViaOAuth?.scopes || [],
+        userId: auth.authenticatedViaToken?.userId || auth.authenticatedViaOAuth?.userId || auth.userId || null,
+        tokenId: auth.authenticatedViaToken?.tokenId || auth.authenticatedViaOAuth?.grantId || null,
+        aiProfileToken: auth.aiProfileToken,
+        aiProfileName: auth.aiProfileName,
+        aiProfileIcon: auth.aiProfileIcon,
+        aiProfileColor: auth.aiProfileColor,
+        aiProfileDescription: auth.aiProfileDescription,
+        aiProfileRole: auth.aiProfileRole,
+        aiProfileProvider: auth.aiProfileProvider,
+        aiProfileModel: auth.aiProfileModel,
+        aiProfileSurfaceType: auth.aiProfileSurfaceType,
+        actorType,
+        requestId: String(requestId || req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || undefined,
+        ip: req.socket?.remoteAddress || null,
+        userAgent: requestHeader(req, 'user-agent', '') || null,
+    };
+}
 // === SECTION: Request header helpers ===
 export function requestHeader(req, name, fallback = '') {
     const value = req.headers?.[name.toLowerCase()];

package/dist/server/routes/sync.integration.test.js

@@ -344,6 +344,10 @@ describe('Server Routes Workspace Sync Integration', () => {
                         username: 'codex',
                         icon: 'Bot',
                         color: '#0ea5e9',
+                        description: 'Terminal-first coding agent',
+                        role: 'Implementer',
+                        provider: 'OpenAI',
+                        model: 'gpt-5.4',
                         surfaceType: 'coding_tool',
                         createdAt: '2026-03-22T10:00:00.000Z',
                         updatedAt: '2026-03-22T10:05:00.000Z',
@@ -361,6 +365,10 @@ describe('Server Routes Workspace Sync Integration', () => {
                 id: 'ai-profile-codex',
                 name: 'Codex',
                 username: 'codex',
+                description: 'Terminal-first coding agent',
+                role: 'Implementer',
+                provider: 'OpenAI',
+                model: 'gpt-5.4',
                 surfaceType: 'coding_tool'
             })
         ]);
@@ -1757,6 +1765,18 @@ describe('Server Routes Workspace Sync Integration', () => {
         const pushRes = createMockRes();
         await pushMatch?.handler(pushReq, pushRes, {});
         expect(pushRes.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const pushBody = readJsonBody(pushRes);
+        expect(Array.isArray(pushBody?.appliedTaskUpserts)).toBe(true);
+        expect(pushBody?.appliedTaskUpserts).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                archived: false,
+                task: expect.objectContaining({
+                    id: taskId,
+                    title: 'Offline provisional task',
+                    referenceNumber: 1
+                })
+            })
+        ]));
         const persisted = core.getTask(taskId, workspaceId);
         expect(persisted?.referenceNumber).toBe(1);
         expect(Date.parse(String(persisted?.updatedAt || ''))).toBeGreaterThan(Date.parse(staleUpdatedAt));

package/dist/server/routes/sync.js

@@ -5,15 +5,14 @@ import { WorkspaceAssetStore, } from '../../storage/workspaceAssetStore.js';
 import { resolveSessionCookieAttributesForRequest } from '../auth.js';
 import { decryptDocument, ENCRYPTION_PREFIX } from '../../sync/encryptionService.js';
 import { isAiProfileSurfaceType } from '../../shared/aiProfileSurfaceType.js';
-import { getTaskMutationTieBreak, getTaskMutationWatermark } from '../../sync/workspaceSyncSurface.js';
-import { normalizeTaskSyncPayload, taskSyncPayloadToCoreTask } from '../../sync/taskSyncPayload.js';
-import { normalizeBinaryAssetDeleteSyncPayload, normalizeBinaryAssetSyncPayload, normalizeDocumentDeleteSyncPayload, normalizeDocumentSyncPayload, serializeBinaryAssetSyncPayload, serializeDocumentSyncPayload } from '../../sync/contentSyncPayload.js';
+import { serializeTaskForSync, } from '../../sync/taskSyncPayload.js';
+import { serializeBinaryAssetSyncPayload, serializeDocumentSyncPayload, } from '../../sync/contentSyncPayload.js';
 import { createContentSyncState } from '../../sync/contentSyncState.js';
-import { normalizeAiProfileSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDeleteSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, } from '../../sync/collaborationSyncPayload.js';
+import { normalizeAiProfileSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, } from '../../sync/collaborationSyncPayload.js';
 import { createCollaborationSyncState } from '../../sync/collaborationSyncState.js';
 import { buildWorkspacePullFeed } from '../../sync/workspacePullFeed.js';
 import { normalizeInitiativeSyncPayload, normalizeTaxonomySyncPayload, normalizeWorkstreamSyncPayload, } from '../../sync/planningSyncPayload.js';
-import { applyAiProfileAndMemberSyncChanges, applyCollaborationSyncChanges, applyContentSyncChanges, applyPlanningSyncChanges, resolveSyncConflictOrdering, } from '../../sync/syncApplyHandlers.js';
+import { applyAiProfileAndMemberSyncChanges, applyCollaborationSyncChanges, applyContentSyncChanges, applyPlanningSyncChanges, applyPreparedTaskSyncSnapshot, applyTaskActivitySyncChanges, applyTaskSyncDeletes, classifyWorkspaceSyncChanges, prepareTaskSyncSnapshotApply, } from '../../sync/syncApplyHandlers.js';
 import { applyWorkspaceRepair } from '../../sync/workspaceRepair.js';
 function decodeWorkspaceSyncCursor(raw) {
     const value = String(raw || '').trim();
@@ -60,6 +59,40 @@ function normalizeIncomingAiProfileSurfaceType(value, context) {
     }
     return normalized;
 }
+function normalizeTaskEventSyncPayload(raw, workspaceId, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const id = String(source.id || '').trim();
+    const taskId = String(source.taskId || source.task_id || '').trim();
+    const action = String(source.action || '').trim();
+    const actor = String(source.actor || 'system').trim() || 'system';
+    const createdAt = String(source.createdAt || source.created_at || sourceWatermark || '').trim();
+    if (!id || !taskId || !action || !Number.isFinite(Date.parse(createdAt)))
+        return null;
+    const actorType = source.actorType === 'ai' || source.actorType === 'human' || source.actorType === 'system'
+        ? source.actorType
+        : source.actor_type === 'ai' || source.actor_type === 'human' || source.actor_type === 'system'
+            ? source.actor_type
+            : actor.startsWith('ai-profile-')
+                ? 'ai'
+                : actor === 'system'
+                    ? 'system'
+                    : 'human';
+    const details = source.details && typeof source.details === 'object' && !Array.isArray(source.details)
+        ? source.details
+        : {};
+    return {
+        id,
+        taskId,
+        workspaceId,
+        action,
+        actor,
+        actorType,
+        details,
+        createdAt
+    };
+}
 export function registerSyncRoutes(deps) {
     const { addRoute, core, context, auditAuthAction, resolveErrorStatusCode, requestWorkspaceId, resolveRequestAccess, isReservedWorkspaceId, createSessionTokenCookie } = deps;
     const readPushIdempotency = (workspaceId, key) => {
@@ -190,32 +223,7 @@ export function registerSyncRoutes(deps) {
         workspaceDocumentSnapshotCache,
     });
     const collaborationSyncState = createCollaborationSyncState({ core });
-    const hasTaskReferenceNumberDrift = (workspaceId, task) => {
-        const taskId = String(task?.id || '').trim();
-        const incomingReferenceNumber = Number.isFinite(Number(task?.referenceNumber))
-            ? Math.max(1, Math.floor(Number(task?.referenceNumber)))
-            : null;
-        if (!incomingReferenceNumber)
-            return false;
-        const existingTask = core.resolveTaskIdentifier(`T-${incomingReferenceNumber}`, workspaceId);
-        if (!existingTask || existingTask.id === taskId)
-            return false;
-        recordSyncDiagnostic(workspaceId, 'apply', 'Detected task reference number mismatch during normal sync.', {
-            source: 'tasks.referenceNumber.mismatch',
-            taskId: taskId || null,
-            taskTitle: typeof task?.title === 'string' ? task.title.trim() || null : null,
-            existingTaskId: existingTask.id,
-            existingTaskTitle: existingTask.title || null,
-            referenceLabel: `T-${incomingReferenceNumber}`,
-            existingReferenceNumber: existingTask.referenceNumber ?? incomingReferenceNumber,
-            incomingReferenceNumber
-        });
-        return true;
-    };
     const dispatchWorkspaceSyncChanges = async (workspaceId, incomingChanges, options) => {
-        const tasks = [];
-        const archived = [];
-        const incomingTaskDeletes = new Map();
         const emittedEventIds = new Set();
         const unsubscribeRealtime = core.onRealtimeMutation((event) => {
             const eventWorkspaceId = String(event?.workspaceId || '').trim();
@@ -225,224 +233,63 @@ export function registerSyncRoutes(deps) {
             if (eventId)
                 emittedEventIds.add(eventId);
         });
-        let incomingTaxonomies = null;
-        let incomingTaxonomyState = null;
-        let incomingTaxonomiesUpdatedAt = '';
-        const incomingInitiatives = new Map();
-        const incomingWorkstreams = new Map();
-        const incomingAiProfiles = new Map();
-        const incomingDocuments = [];
-        const incomingDocumentDeletes = new Map();
-        const incomingDocumentReviewSessions = new Map();
-        const incomingDocumentReviewSessionDeletes = new Map();
-        const incomingDocumentReviewComments = new Map();
-        const incomingDocumentReviewCommentDeletes = new Map();
-        const incomingAnnotatedAttachmentSessions = new Map();
-        const incomingAnnotatedAttachmentSessionDeletes = new Map();
-        const incomingAssets = [];
-        const incomingAssetDeletes = new Map();
         try {
-            for (const change of incomingChanges) {
-                const raw = change;
-                const op = String(raw.op || '').trim().toLowerCase();
-                if (op === 'taxonomy-upsert') {
-                    const taxonomy = normalizeTaxonomySyncPayload(raw);
-                    if (taxonomy?.taxonomyState)
-                        incomingTaxonomyState = taxonomy.taxonomyState;
-                    if (Array.isArray(taxonomy?.taxonomies))
-                        incomingTaxonomies = taxonomy.taxonomies;
-                    if (taxonomy?.updatedAt)
-                        incomingTaxonomiesUpdatedAt = taxonomy.updatedAt;
-                    continue;
-                }
-                if (op === 'initiative-upsert') {
-                    const initiative = normalizeInitiativeSyncPayload(raw.initiative, String(raw.updatedAt || raw.watermark || '').trim());
-                    if (initiative)
-                        incomingInitiatives.set(initiative.id, initiative);
-                    continue;
-                }
-                if (op === 'workstream-upsert') {
-                    const workstream = normalizeWorkstreamSyncPayload(raw.workstream, String(raw.updatedAt || raw.watermark || '').trim());
-                    if (workstream)
-                        incomingWorkstreams.set(workstream.id, workstream);
-                    continue;
-                }
-                if (op === 'ai-profile-upsert') {
-                    const profile = normalizeAiProfileSyncPayload(raw.profile, workspaceId, normalizeIncomingAiProfileSurfaceType, 'apply.aiProfileUpsert');
-                    const profileId = String(profile?.id || '').trim();
-                    if (profileId && profile) {
-                        const profileWorkspaceId = String(profile.workspaceId || '').trim();
-                        if (profileWorkspaceId && profileWorkspaceId !== workspaceId) {
-                            recordSyncDiagnostic(workspaceId, 'apply', `Rejected ai-profile-upsert for profile ${profileId}: workspace mismatch (expected ${workspaceId}, got ${profileWorkspaceId}).`, {
-                                source: 'apply.aiProfileWorkspaceMismatch',
-                                workspaceId,
-                                profileId,
-                                expectedWorkspaceId: workspaceId,
-                                receivedWorkspaceId: profileWorkspaceId
-                            });
-                            continue;
-                        }
-                        incomingAiProfiles.set(profileId, {
-                            ...profile,
-                            workspaceId,
-                            createdAt: profile.createdAt || String(raw.updatedAt || raw.watermark || '').trim(),
-                            updatedAt: profile.updatedAt || String(raw.updatedAt || raw.watermark || '').trim(),
-                        });
-                    }
-                    continue;
-                }
-                if (op === 'document-upsert') {
-                    const document = normalizeDocumentSyncPayload(raw, normalizeWorkspaceSyncDocumentPath);
-                    if (document)
-                        incomingDocuments.push(document);
-                    continue;
-                }
-                if (op === 'document-delete') {
-                    const deletedDocument = normalizeDocumentDeleteSyncPayload(raw, normalizeWorkspaceSyncDocumentPath);
-                    if (deletedDocument)
-                        incomingDocumentDeletes.set(deletedDocument.path, deletedDocument.deletedAt);
-                    continue;
-                }
-                if (op === 'asset-upsert') {
-                    const asset = normalizeBinaryAssetSyncPayload(raw, (rawPath) => normalizeTaskDataRelativePath(String(rawPath || '').trim()));
-                    if (asset)
-                        incomingAssets.push(asset);
-                    continue;
-                }
-                if (op === 'asset-delete') {
-                    const deletedAsset = normalizeBinaryAssetDeleteSyncPayload(raw, (rawPath) => normalizeTaskDataRelativePath(String(rawPath || '').trim()));
-                    if (deletedAsset)
-                        incomingAssetDeletes.set(deletedAsset.path, deletedAsset.deletedAt);
-                    continue;
-                }
-                if (op === 'document-review-session-upsert') {
-                    const session = normalizeDocumentReviewSessionSyncPayload(raw.session, String(raw.updatedAt || raw.watermark || '').trim());
-                    if (session)
-                        incomingDocumentReviewSessions.set(session.id, session);
-                    continue;
-                }
-                if (op === 'document-review-session-delete') {
-                    const deletedSession = normalizeDeleteSyncPayload(raw, 'sessionId');
-                    if (deletedSession)
-                        incomingDocumentReviewSessionDeletes.set(deletedSession.id, deletedSession.deletedAt);
-                    continue;
-                }
-                if (op === 'document-review-comment-upsert') {
-                    const comment = normalizeDocumentReviewCommentSyncPayload(raw.comment, { sourceWatermark: String(raw.updatedAt || raw.watermark || '').trim() });
-                    if (comment)
-                        incomingDocumentReviewComments.set(comment.id, comment);
-                    continue;
-                }
-                if (op === 'document-review-comment-delete') {
-                    const deletedComment = normalizeDeleteSyncPayload(raw, 'commentId');
-                    if (deletedComment)
-                        incomingDocumentReviewCommentDeletes.set(deletedComment.id, deletedComment.deletedAt);
-                    continue;
-                }
-                if (op === 'annotated-attachment-session-upsert') {
-                    const session = normalizeAnnotatedAttachmentSessionSyncPayload(raw.session, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
-                    if (session)
-                        incomingAnnotatedAttachmentSessions.set(session.id, session);
-                    continue;
-                }
-                if (op === 'annotated-attachment-session-delete') {
-                    const deletedSession = normalizeDeleteSyncPayload(raw, 'sessionId');
-                    if (deletedSession)
-                        incomingAnnotatedAttachmentSessionDeletes.set(deletedSession.id, deletedSession.deletedAt);
-                    continue;
-                }
-                if (op !== 'delete')
-                    continue;
-                const task = normalizeTaskSyncPayload(raw.task);
-                const deleteTaskId = String(raw.taskId || raw.id || task?.id || '').trim();
-                if (deleteTaskId) {
-                    incomingTaskDeletes.set(deleteTaskId, String(raw.deletedAt || raw.watermark || new Date().toISOString()).trim());
-                }
-            }
-            for (const change of incomingChanges) {
-                const raw = change;
-                const op = String(raw.op || '').trim().toLowerCase();
-                if (op === 'delete'
-                    || op === 'initiative-upsert'
-                    || op === 'workstream-upsert'
-                    || op === 'document-upsert'
-                    || op === 'document-delete'
-                    || op === 'asset-upsert'
-                    || op === 'asset-delete'
-                    || op === 'document-review-session-upsert'
-                    || op === 'document-review-session-delete'
-                    || op === 'document-review-comment-upsert'
-                    || op === 'document-review-comment-delete'
-                    || op === 'annotated-attachment-session-upsert'
-                    || op === 'annotated-attachment-session-delete')
-                    continue;
-                const task = normalizeTaskSyncPayload(raw.task);
-                if (!task)
-                    continue;
-                const taskId = String(task.id || '').trim();
-                hasTaskReferenceNumberDrift(workspaceId, task);
-                const deleteWatermark = taskId ? String(incomingTaskDeletes.get(taskId) || '').trim() : '';
-                if (taskId && deleteWatermark) {
-                    const compareAgainstDelete = resolveSyncConflictOrdering(deleteWatermark, String(task.updatedAt || task.createdAt || '').trim(), `delete:${taskId}`, getTaskMutationTieBreak(task, raw.archived === true || task?.isArchived === true));
-                    if (compareAgainstDelete >= 0)
-                        continue;
-                }
-                const markedArchived = raw.archived === true || task?.isArchived === true;
-                if (markedArchived)
-                    archived.push(task);
-                else
-                    tasks.push(task);
-            }
-            for (const [taskId, deleteWatermark] of incomingTaskDeletes.entries()) {
-                try {
-                    const existingTask = core.getTask(taskId, workspaceId);
-                    if (existingTask) {
-                        const compareAgainstExisting = resolveSyncConflictOrdering(deleteWatermark, getTaskMutationWatermark(existingTask), `delete:${taskId}`, getTaskMutationTieBreak(existingTask, Boolean(existingTask.isArchived)));
-                        if (compareAgainstExisting < 0)
-                            continue;
-                    }
-                    core.deleteTaskForSync(taskId, workspaceId, { persistBackup: false });
-                }
-                catch (error) {
-                    recordSyncDiagnostic(workspaceId, 'apply', 'Failed to delete task during sync apply.', {
-                        source: 'apply.deleteTask',
-                        taskId,
-                        error: String(error?.message || error || '')
-                    });
-                }
-            }
+            const applyModel = classifyWorkspaceSyncChanges({
+                workspaceId,
+                incomingChanges,
+                normalizeWorkspaceSyncDocumentPath,
+                normalizeTaskAssetPath: (rawPath) => normalizeTaskDataRelativePath(String(rawPath || '').trim()),
+                normalizeIncomingAiProfileSurfaceType,
+                normalizeTaskEventSyncPayload,
+                recordSyncDiagnostic,
+            });
             applyPlanningSyncChanges({
                 core,
                 workspaceId,
-                incomingInitiatives,
-                incomingWorkstreams,
-                incomingTaxonomies,
-                incomingTaxonomyState,
-                incomingTaxonomiesUpdatedAt,
+                incomingInitiatives: applyModel.planning.incomingInitiatives,
+                incomingWorkstreams: applyModel.planning.incomingWorkstreams,
+                incomingTaxonomies: applyModel.planning.incomingTaxonomies,
+                incomingTaxonomyState: applyModel.planning.incomingTaxonomyState,
+                incomingTaxonomiesUpdatedAt: applyModel.planning.incomingTaxonomiesUpdatedAt,
                 workspaceTaxonomySyncMeta,
                 recordSyncDiagnostic,
             });
             applyAiProfileAndMemberSyncChanges({
                 core,
                 workspaceId,
-                incomingAiProfiles,
+                incomingAiProfiles: applyModel.profiles.incomingAiProfiles,
                 workspaceMembers: options?.workspaceMembers,
                 recordSyncDiagnostic,
                 assertSyncedAiProfilesPersisted,
                 createSyncRouteError,
             });
-            validateTaskActorAssignments(workspaceId, tasks, archived);
+            const preparedTaskSnapshot = prepareTaskSyncSnapshotApply({
+                core,
+                workspaceId,
+                taskMutations: applyModel.taskMutations,
+                recordSyncDiagnostic,
+            });
+            validateTaskActorAssignments(workspaceId, preparedTaskSnapshot.tasks, preparedTaskSnapshot.archived);
             await applyContentSyncChanges({
                 core,
                 workspaceId,
-                incomingDocuments,
-                incomingDocumentDeletes,
-                incomingAssets,
-                incomingAssetDeletes,
+                incomingDocuments: applyModel.content.incomingDocuments,
+                incomingDocumentDeletes: applyModel.content.incomingDocumentDeletes,
+                incomingAssets: applyModel.content.incomingAssets,
+                incomingAssetDeletes: applyModel.content.incomingAssetDeletes,
                 basePath: core.getPaths().basePath,
                 hasObjectStorageClient: () => Boolean(getObjectStorageClient()),
                 hasDocumentSyncMetadataDrift: contentSyncState.hasDocumentSyncMetadataDrift,
                 hasBinaryAssetSyncMetadataDrift: contentSyncState.hasBinaryAssetSyncMetadataDrift,
+                getExistingDocument: (docPath, targetWorkspaceId) => {
+                    const asset = workspaceAssetStore?.getByStorageKey(docPath, targetWorkspaceId) || null;
+                    return asset
+                        ? {
+                            updatedAt: asset.updatedAt,
+                            contentHash: asset.contentSha256
+                        }
+                        : null;
+                },
                 writeWorkspaceSyncDocument: contentSyncState.writeWorkspaceSyncDocument,
                 deleteWorkspaceSyncDocument: contentSyncState.deleteWorkspaceSyncDocument,
                 writeWorkspaceSyncBinaryAsset: contentSyncState.writeWorkspaceSyncBinaryAsset,
@@ -454,20 +301,34 @@ export function registerSyncRoutes(deps) {
             applyCollaborationSyncChanges({
                 core,
                 workspaceId,
-                incomingDocumentReviewSessions,
-                incomingDocumentReviewSessionDeletes,
-                incomingDocumentReviewComments,
-                incomingDocumentReviewCommentDeletes,
-                incomingAnnotatedAttachmentSessions,
-                incomingAnnotatedAttachmentSessionDeletes,
+                incomingDocumentReviewSessions: applyModel.collaboration.incomingDocumentReviewSessions,
+                incomingDocumentReviewSessionDeletes: applyModel.collaboration.incomingDocumentReviewSessionDeletes,
+                incomingDocumentReviewComments: applyModel.collaboration.incomingDocumentReviewComments,
+                incomingDocumentReviewCommentDeletes: applyModel.collaboration.incomingDocumentReviewCommentDeletes,
+                incomingAnnotatedAttachmentSessions: applyModel.collaboration.incomingAnnotatedAttachmentSessions,
+                incomingAnnotatedAttachmentSessionDeletes: applyModel.collaboration.incomingAnnotatedAttachmentSessionDeletes,
+                recordSyncDiagnostic,
+                createSyncRouteError,
+            });
+            const deleteCount = applyTaskSyncDeletes({
+                core,
+                workspaceId,
+                taskMutations: applyModel.taskMutations,
+                recordSyncDiagnostic,
+            });
+            const result = applyPreparedTaskSyncSnapshot({
+                core,
+                workspaceId,
+                prepared: preparedTaskSnapshot,
+            });
+            applyTaskActivitySyncChanges({
+                core,
+                workspaceId,
+                incomingTaskEvents: applyModel.taskActivity.incomingTaskEvents,
                 recordSyncDiagnostic,
                 createSyncRouteError,
             });
-            const result = core.applyWorkspaceSyncSnapshot({
-                tasks: tasks.map(taskSyncPayloadToCoreTask),
-                archived: archived.map(taskSyncPayloadToCoreTask)
-            }, workspaceId);
-            return { result, deleteCount: incomingTaskDeletes.size, emittedEventIds: Array.from(emittedEventIds) };
+            return { result, deleteCount, emittedEventIds: Array.from(emittedEventIds) };
         }
         finally {
             unsubscribeRealtime();
@@ -1257,6 +1118,10 @@ export function registerSyncRoutes(deps) {
             }
         }
         let incomingChanges = Array.isArray(body?.changes) ? body.changes : [];
+        const incomingTaskUpsertIds = incomingChanges
+            .filter((change) => change?.op === 'upsert')
+            .map((change) => String(change.task?.id || '').trim())
+            .filter((taskId) => taskId.length > 0);
         const allowReferenceNumberReassignment = body?.repair === true;
         // Decrypt asset and document content if TASKFORCE_SYNC_KEY is configured on this server.
         // The local runtime encrypts content before pushing; the cloud must decrypt before writing to storage.
@@ -1311,12 +1176,20 @@ export function registerSyncRoutes(deps) {
             const { result, deleteCount, emittedEventIds } = await dispatchWorkspaceSyncChanges(targetWorkspaceId, incomingChanges, {
                 allowReferenceNumberReassignment
             });
+            const appliedTaskUpserts = incomingTaskUpsertIds
+                .map((taskId) => core.getTask(taskId, targetWorkspaceId))
+                .filter((task) => Boolean(task))
+                .map((task) => ({
+                archived: Boolean(task.isArchived),
+                task: serializeTaskForSync(task)
+            }));
             const durationMs = Date.now() - startedAtMs;
             const payload = JSON.stringify({
                 success: true,
                 workspaceId: targetWorkspaceId,
                 idempotencyKey: idempotencyKey || null,
                 emittedEventIds,
+                appliedTaskUpserts,
                 result,
                 durationMs
             });