@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/sync/engine/workspaceSyncV2ChangeDispatcher.js

@@ -0,0 +1,992 @@
+import { normalizeTaskDataRelativePath } from '../../storage/objectStorageClient.js';
+import { assertSynchronousTransactionResult } from '../../storage/databaseAdapter.js';
+import { isAiProfileSurfaceType, parseAiProfileSurfaceType, } from '../../shared/aiProfileSurfaceType.js';
+import { isAiProfileSeatScope, } from '../../shared/aiProfileSeatScope.js';
+import { applyAiProfileAndMemberSyncChanges, applyCollaborationSyncChanges, applyContentSyncChanges, applyDurableTaskPullRevisions, applyPlanningSyncChanges, applyPreparedTaskSyncSnapshot, applyTaskActivitySyncChanges, applyTaskRelationshipSyncChanges, applyTaskSyncDeletes, applyTaxonomySyncChanges, classifyWorkspaceSyncChanges, prepareDurableTaskPullMutations, prepareTaskSyncSnapshotApply, resolveSyncConflictOrdering, } from '../syncApplyHandlers.js';
+import { WorkspaceSyncDurabilityStore } from '../v3/syncDurabilityStore.js';
+import { assertWorkspaceSyncV2TaskCarrierRootsExist, prepareWorkspaceSyncV2TaskCarriers, } from '../v3/workspaceSyncV2ProjectionExclusions.js';
+import { resolveV3OwnedTaskDeleteIds, resolveV3OwnedTaskLifecycleIds, resolveV3OwnedTaskMetadataIds, resolveV3OwnedTaskReopenAssigneeIds, resolveV3OwnedTaskTaxonomyIds, } from '../v3/taskMetadataCoexistence.js';
+import { assertWorkspaceSyncV2MetadataOnlyApplyPreflight, } from './workspaceSyncEngineLocalApply.js';
+function createSyncRouteError(message, details, options) {
+    const error = new Error(message);
+    error.code = options?.code || 'SYNC_APPLY_FAILED';
+    error.statusCode = options?.statusCode || 500;
+    error.details = details;
+    return error;
+}
+function normalizeIncomingAiProfileSurfaceType(value, context) {
+    if (value === undefined || value === null)
+        return null;
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        return null;
+    if (normalized === 'other')
+        return parseAiProfileSurfaceType(normalized);
+    if (!isAiProfileSurfaceType(normalized)) {
+        throw createSyncRouteError(`Invalid ai profile surfaceType "${normalized}"`, { ...context, surfaceType: normalized }, { code: 'AI_PROFILE_SURFACE_TYPE_INVALID', statusCode: 400 });
+    }
+    return normalized;
+}
+function normalizeIncomingAiProfileSeatScope(value, context) {
+    if (value === undefined || value === null)
+        return null;
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        return null;
+    if (!isAiProfileSeatScope(normalized)) {
+        throw createSyncRouteError(`Invalid ai profile seatScope "${normalized}"`, { ...context, seatScope: normalized }, { code: 'AI_PROFILE_SEAT_SCOPE_INVALID', statusCode: 400 });
+    }
+    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 entityType = source.entityType === 'initiative' || source.entityType === 'workstream'
+        ? source.entityType
+        : source.entity_type === 'initiative' || source.entity_type === 'workstream'
+            ? source.entity_type
+            : 'task';
+    const taskId = String(source.taskId || source.task_id || '').trim();
+    const entityId = String(source.entityId || source.entity_id || taskId).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 || !entityId || !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,
+        workspaceId,
+        entityType,
+        entityId,
+        taskId: entityType === 'task' ? (taskId || entityId) : undefined,
+        action,
+        actor,
+        actorType,
+        details,
+        createdAt,
+    };
+}
+export function createWorkspaceSyncV2ChangeDispatcher(dependencies) {
+    const { core, contentSyncState, workspaceAssetStore, recordSyncDiagnostic, } = dependencies;
+    const now = dependencies.now;
+    const workspaceTaxonomySyncMeta = new Map();
+    const validateTaskActorAssignments = (workspaceId, tasks, archived) => {
+        const entries = [...tasks, ...archived];
+        for (const task of entries) {
+            const assignee = String(task.assignee || '').trim();
+            if (!assignee || assignee === 'unassigned')
+                continue;
+            const actor = core.resolveWorkspaceActor(workspaceId, assignee);
+            if (actor && actor.meta?.unresolved !== true)
+                continue;
+            if (actor?.kind !== 'ai')
+                continue;
+            throw createSyncRouteError(`Task ${String(task.id || '').trim() || '(unknown task)'} references unresolved assignee ${assignee}.`, {
+                source: 'apply.assigneeValidation',
+                workspaceId,
+                taskId: String(task.id || '').trim() || null,
+                assignee,
+            }, { code: 'TASK_ACTOR_RESOLUTION_FAILED', statusCode: 400 });
+        }
+    };
+    const assertSyncedAiProfilesPersisted = (workspaceId, incomingAiProfiles) => {
+        if (incomingAiProfiles.size === 0)
+            return;
+        const persistedIds = new Set(core.listAiProfiles(workspaceId, { includeArchived: true })
+            .map((profile) => String(profile.id || '').trim())
+            .filter(Boolean));
+        for (const profile of incomingAiProfiles.values()) {
+            if (persistedIds.has(profile.id))
+                continue;
+            throw createSyncRouteError(`AI profile ${profile.id} was not persisted during sync apply.`, {
+                source: 'apply.aiProfileIntegrityCheck',
+                workspaceId,
+                profileId: profile.id,
+                expectedAiProfileCount: incomingAiProfiles.size,
+                persistedAiProfileCount: persistedIds.size,
+            }, { code: 'AI_PROFILE_SYNC_APPLY_FAILED', statusCode: 500 });
+        }
+    };
+    const classifyAndPrepareTaskCarriers = (workspaceId, incomingChanges, options, metadataOnly = false) => {
+        const applyModel = classifyWorkspaceSyncChanges({
+            workspaceId,
+            incomingChanges,
+            normalizeWorkspaceSyncDocumentPath: dependencies.normalizeWorkspaceSyncDocumentPath,
+            normalizeTaskAssetPath: (rawPath) => normalizeTaskDataRelativePath(String(rawPath || '').trim()),
+            normalizeIncomingAiProfileSurfaceType,
+            normalizeIncomingAiProfileSeatScope,
+            normalizeTaskEventSyncPayload,
+            recordSyncDiagnostic,
+        });
+        if (metadataOnly) {
+            assertWorkspaceSyncV2MetadataOnlyApplyPreflight(incomingChanges);
+        }
+        const v2ExcludedProjections = new Set(options.v2ExcludedProjections || []);
+        if ((v2ExcludedProjections.has('task/root-v1') && applyModel.taskMutations.deletes.size > 0)
+            || (v2ExcludedProjections.has('task-relationship/full-v1') && applyModel.taskRelationships.size > 0)
+            || (v2ExcludedProjections.has('taxonomy/full-v1') && (applyModel.planning.incomingTaxonomyState !== null
+                || applyModel.planning.incomingTaxonomies !== null))
+            || (v2ExcludedProjections.has('initiative/full-v1') && applyModel.planning.incomingInitiatives.size > 0)
+            || (v2ExcludedProjections.has('workstream/full-v1') && applyModel.planning.incomingWorkstreams.size > 0)
+            || (v2ExcludedProjections.has('entity-event/full-v1')
+                && applyModel.taskActivity.incomingTaskEvents.size > 0)) {
+            throw createSyncRouteError('Cloud pull contained content from an excluded v2 projection.', { excludedProjections: Array.from(v2ExcludedProjections) }, { code: 'SYNC_V2_EXCLUDED_PROJECTION_PRESENT', statusCode: 409 });
+        }
+        const taskMutationsForApply = prepareWorkspaceSyncV2TaskCarriers(applyModel.taskMutations, v2ExcludedProjections, (taskId) => core.getTask(taskId, workspaceId));
+        if (v2ExcludedProjections.has('task/root-v1')) {
+            assertWorkspaceSyncV2TaskCarrierRootsExist(taskMutationsForApply, (taskId) => Boolean(core.getTask(taskId, workspaceId)));
+        }
+        return { applyModel, taskMutationsForApply, v2ExcludedProjections };
+    };
+    const prepareTaskSnapshotForDispatch = (workspaceId, taskMutationsForApply, v2ExcludedProjections, options) => {
+        const prepared = prepareTaskSyncSnapshotApply({
+            core,
+            workspaceId,
+            taskMutations: taskMutationsForApply,
+            recordSyncDiagnostic,
+            ...(v2ExcludedProjections.has('task/root-v1') ? {
+                v3OwnedTaskRootIds: new Set(taskMutationsForApply.upserts.map((mutation) => mutation.task.id)),
+            } : {}),
+            ...(options.coexistenceDirection && taskMutationsForApply.upserts.length > 0
+                ? {
+                    v3OwnedTaskMetadataIds: resolveV3OwnedTaskMetadataIds({
+                        direction: options.coexistenceDirection,
+                        assertedActiveTaskIds: options.assertedActiveV3TaskMetadataIds,
+                        ownership: new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()).listTaskMetadataOwnership({
+                            tenantId: core.getTenantId(),
+                            workspaceId,
+                        }),
+                    }),
+                    v3OwnedTaskTaxonomyIds: resolveV3OwnedTaskTaxonomyIds({
+                        direction: options.coexistenceDirection,
+                        ownership: new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()).listTaskTaxonomyProjectionOwnership({
+                            tenantId: core.getTenantId(),
+                            workspaceId,
+                            taskIds: taskMutationsForApply.upserts.map((mutation) => mutation.task.id),
+                        }),
+                    }),
+                    v3OwnedTaskDeleteIds: resolveV3OwnedTaskDeleteIds({
+                        direction: options.coexistenceDirection,
+                        assertedActiveTaskIds: options.assertedActiveV3TaskDeleteIds,
+                        ownership: new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()).listTaskMetadataOwnership({
+                            tenantId: core.getTenantId(),
+                            workspaceId,
+                        }),
+                    }),
+                    v3OwnedTaskLifecycleIds: resolveV3OwnedTaskLifecycleIds({
+                        direction: options.coexistenceDirection,
+                        assertedActiveTaskIds: options.assertedActiveV3TaskLifecycleIds,
+                        ownership: new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()).listTaskMetadataOwnership({
+                            tenantId: core.getTenantId(),
+                            workspaceId,
+                        }),
+                    }),
+                    v3OwnedTaskReopenAssigneeIds: resolveV3OwnedTaskReopenAssigneeIds({
+                        direction: options.coexistenceDirection,
+                        assertedActiveTaskIds: options.assertedActiveV3TaskReopenAssigneeIds,
+                        ownership: new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()).listTaskMetadataOwnership({
+                            tenantId: core.getTenantId(),
+                            workspaceId,
+                        }),
+                    }),
+                    coexistenceDirection: options.coexistenceDirection,
+                }
+                : {}),
+        });
+        validateTaskActorAssignments(workspaceId, prepared.tasks, prepared.archived);
+        return prepared;
+    };
+    const dispatch = async (workspaceId, incomingChanges, options = {}) => {
+        const emittedEventIds = new Set();
+        const unsubscribeRealtime = core.onRealtimeMutation((event) => {
+            const eventWorkspaceId = String(event?.workspaceId || '').trim();
+            if (eventWorkspaceId !== workspaceId)
+                return;
+            const eventId = String(event?.eventId || '').trim();
+            if (eventId)
+                emittedEventIds.add(eventId);
+        });
+        try {
+            const { applyModel, taskMutationsForApply, v2ExcludedProjections, } = classifyAndPrepareTaskCarriers(workspaceId, incomingChanges, options);
+            applyTaxonomySyncChanges({
+                core,
+                workspaceId,
+                incomingTaxonomies: applyModel.planning.incomingTaxonomies,
+                incomingTaxonomyState: applyModel.planning.incomingTaxonomyState,
+                incomingTaxonomiesUpdatedAt: applyModel.planning.incomingTaxonomiesUpdatedAt,
+                incomingDurableRevision: applyModel.planning.incomingTaxonomyDurableRevision,
+                workspaceTaxonomySyncMeta,
+                coexistenceDirection: options.coexistenceDirection,
+                assertedActiveV3Taxonomy: options.assertedActiveV3Taxonomy,
+            });
+            applyAiProfileAndMemberSyncChanges({
+                core,
+                workspaceId,
+                incomingAiProfiles: applyModel.profiles.incomingAiProfiles,
+                workspaceMembers: options.workspaceMembers,
+                recordSyncDiagnostic,
+                assertSyncedAiProfilesPersisted,
+                createSyncRouteError,
+            });
+            const preparedTaskSnapshot = prepareTaskSnapshotForDispatch(workspaceId, taskMutationsForApply, v2ExcludedProjections, options);
+            const contentApply = {
+                core,
+                workspaceId,
+                incomingDocuments: applyModel.content.incomingDocuments,
+                incomingDocumentDeletes: applyModel.content.incomingDocumentDeletes,
+                incomingAssets: applyModel.content.incomingAssets,
+                incomingAssetDeletes: applyModel.content.incomingAssetDeletes,
+                basePath: core.getPaths().basePath,
+                hasObjectStorageClient: dependencies.hasObjectStorageClient,
+                hasDocumentSyncMetadataDrift: contentSyncState.hasDocumentSyncMetadataDrift,
+                hasBinaryAssetSyncMetadataDrift: contentSyncState.hasBinaryAssetSyncMetadataDrift,
+                getExistingDocument: (docPath, targetWorkspaceId) => {
+                    const asset = workspaceAssetStore?.getByStorageKey(docPath, targetWorkspaceId) || null;
+                    return asset
+                        ? {
+                            assetId: asset.assetId,
+                            storageProvider: asset.storageProvider,
+                            updatedAt: asset.updatedAt,
+                            contentHash: asset.contentSha256,
+                        }
+                        : null;
+                },
+                writeWorkspaceSyncDocument: contentSyncState.writeWorkspaceSyncDocument,
+                deleteWorkspaceSyncDocument: contentSyncState.deleteWorkspaceSyncDocument,
+                writeWorkspaceSyncBinaryAsset: contentSyncState.writeWorkspaceSyncBinaryAsset,
+                deleteWorkspaceSyncBinaryAsset: contentSyncState.deleteWorkspaceSyncBinaryAsset,
+                getExistingBinaryAsset: (assetPath, targetWorkspaceId) => workspaceAssetStore?.getByStorageKey(assetPath, targetWorkspaceId) || null,
+                recordSyncDiagnostic,
+                options,
+            };
+            await applyContentSyncChanges({ ...contentApply, phase: 'upserts' });
+            applyPlanningSyncChanges({
+                core,
+                workspaceId,
+                incomingInitiatives: applyModel.planning.incomingInitiatives,
+                incomingWorkstreams: applyModel.planning.incomingWorkstreams,
+                incomingIdentities: applyModel.planning.incomingIdentities,
+                recordSyncDiagnostic,
+                ...(options.coexistenceDirection ? {
+                    coexistenceDirection: options.coexistenceDirection,
+                    assertedActiveV3InitiativeIds: options.assertedActiveV3InitiativeIds,
+                    requiredInitiativeProjectionOwner: options.coexistenceDirection === 'local-pull' ? 'v2' : undefined,
+                    durabilityStore: new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()),
+                    tenantId: core.getTenantId(),
+                    now: now().toISOString(),
+                } : {}),
+            });
+            await applyContentSyncChanges({ ...contentApply, phase: 'deletes' });
+            applyCollaborationSyncChanges({
+                core,
+                workspaceId,
+                incomingDocumentReviewSessions: applyModel.collaboration.incomingDocumentReviewSessions,
+                incomingDocumentReviewSessionDeletes: applyModel.collaboration.incomingDocumentReviewSessionDeletes,
+                incomingDocumentReviewComments: applyModel.collaboration.incomingDocumentReviewComments,
+                incomingDocumentReviewCommentDeletes: applyModel.collaboration.incomingDocumentReviewCommentDeletes,
+                incomingAnnotatedAttachmentSessions: applyModel.collaboration.incomingAnnotatedAttachmentSessions,
+                incomingAnnotatedAttachmentSessionDeletes: applyModel.collaboration.incomingAnnotatedAttachmentSessionDeletes,
+                incomingTaskforceAgents: applyModel.collaboration.incomingTaskforceAgents,
+                incomingAgentRoles: applyModel.collaboration.incomingAgentRoles,
+                incomingTaskforceAgentSkills: applyModel.collaboration.incomingTaskforceAgentSkills,
+                incomingAgentConversations: applyModel.collaboration.incomingAgentConversations,
+                recordSyncDiagnostic,
+                createSyncRouteError,
+            });
+            const finalPreparedTaskSnapshot = options.coexistenceDirection && taskMutationsForApply.upserts.length > 0
+                ? (() => {
+                    const durabilityStore = new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter());
+                    const revisionNow = now().toISOString();
+                    return durabilityStore.runTaskMetadataCoexistenceTransaction({
+                        tenantId: core.getTenantId(),
+                        workspaceId,
+                        direction: options.coexistenceDirection,
+                        taskIds: taskMutationsForApply.upserts.map((mutation) => mutation.task.id),
+                        now: revisionNow,
+                        apply: (ownership) => {
+                            if (options.coexistenceDirection === 'cloud-push'
+                                && taskMutationsForApply.upserts.some((mutation) => mutation.durableRevision))
+                                throw new Error('Task durable revisions are only accepted from the cloud pull feed.');
+                            const durablePull = options.coexistenceDirection === 'local-pull'
+                                ? prepareDurableTaskPullMutations({
+                                    store: durabilityStore,
+                                    tenantId: core.getTenantId(),
+                                    workspaceId,
+                                    taskMutations: taskMutationsForApply,
+                                })
+                                : { taskMutations: taskMutationsForApply, pendingRevisions: [] };
+                            const prepared = prepareTaskSyncSnapshotApply({
+                                core,
+                                workspaceId,
+                                taskMutations: durablePull.taskMutations,
+                                recordSyncDiagnostic,
+                                ...(v2ExcludedProjections.has('task/root-v1') ? {
+                                    v3OwnedTaskRootIds: new Set(durablePull.taskMutations.upserts.map((mutation) => mutation.task.id)),
+                                } : {}),
+                                v3OwnedTaskMetadataIds: resolveV3OwnedTaskMetadataIds({
+                                    direction: options.coexistenceDirection,
+                                    assertedActiveTaskIds: options.assertedActiveV3TaskMetadataIds,
+                                    ownership,
+                                }),
+                                v3OwnedTaskTaxonomyIds: resolveV3OwnedTaskTaxonomyIds({
+                                    direction: options.coexistenceDirection,
+                                    ownership: durabilityStore.listTaskTaxonomyProjectionOwnership({
+                                        tenantId: core.getTenantId(),
+                                        workspaceId,
+                                        taskIds: taskMutationsForApply.upserts.map((mutation) => mutation.task.id),
+                                    }),
+                                }),
+                                v3OwnedTaskDeleteIds: resolveV3OwnedTaskDeleteIds({
+                                    direction: options.coexistenceDirection,
+                                    assertedActiveTaskIds: options.assertedActiveV3TaskDeleteIds,
+                                    ownership,
+                                }),
+                                v3OwnedTaskLifecycleIds: resolveV3OwnedTaskLifecycleIds({
+                                    direction: options.coexistenceDirection,
+                                    assertedActiveTaskIds: options.assertedActiveV3TaskLifecycleIds,
+                                    ownership,
+                                }),
+                                v3OwnedTaskReopenAssigneeIds: resolveV3OwnedTaskReopenAssigneeIds({
+                                    direction: options.coexistenceDirection,
+                                    assertedActiveTaskIds: options.assertedActiveV3TaskReopenAssigneeIds,
+                                    ownership,
+                                }),
+                                coexistenceDirection: options.coexistenceDirection,
+                                recordReferenceNumberMismatch: false,
+                            });
+                            validateTaskActorAssignments(workspaceId, prepared.tasks, prepared.archived);
+                            const result = applyPreparedTaskSyncSnapshot({
+                                core,
+                                workspaceId,
+                                prepared,
+                                deferSideEffects: true,
+                            });
+                            applyDurableTaskPullRevisions({
+                                store: durabilityStore,
+                                tenantId: core.getTenantId(),
+                                workspaceId,
+                                revisions: durablePull.pendingRevisions,
+                                now: revisionNow,
+                            });
+                            return { prepared, result };
+                        },
+                    });
+                })()
+                : {
+                    prepared: preparedTaskSnapshot,
+                    result: applyPreparedTaskSyncSnapshot({
+                        core,
+                        workspaceId,
+                        prepared: preparedTaskSnapshot,
+                    }),
+                };
+            const result = finalPreparedTaskSnapshot.result;
+            const committedTaskIds = finalPreparedTaskSnapshot.result.changedTaskIds || [];
+            if (committedTaskIds.length > 0) {
+                try {
+                    core.notifyWorkspaceSyncSnapshotCommitted(workspaceId, committedTaskIds);
+                }
+                catch (error) {
+                    recordSyncDiagnostic(workspaceId, 'apply', 'Failed to publish committed workspace task snapshot side effects.', {
+                        source: 'apply.taskSnapshotPostCommit',
+                        taskCount: committedTaskIds.length,
+                        error: String(error?.message || error || 'Unknown post-commit failure'),
+                    });
+                }
+            }
+            const protectedTaskCount = finalPreparedTaskSnapshot.prepared.metadataPreservedTaskIds.length;
+            const protectedLifecycleTaskCount = finalPreparedTaskSnapshot.prepared.lifecyclePreservedTaskIds.length;
+            const seededTaskCount = finalPreparedTaskSnapshot.prepared.metadataSeededTaskIds.length;
+            if ((protectedTaskCount > 0 || protectedLifecycleTaskCount > 0 || seededTaskCount > 0) && options.coexistenceDirection) {
+                try {
+                    core.recordSyncEvent(workspaceId, {
+                        eventType: 'apply',
+                        status: 'success',
+                        changeCount: protectedTaskCount + protectedLifecycleTaskCount + seededTaskCount,
+                        requestMs: 0,
+                        details: {
+                            source: 'apply.taskMetadataCoexistenceFirewall',
+                            direction: options.coexistenceDirection,
+                            protectedTaskCount,
+                            protectedLifecycleTaskCount,
+                            seededTaskCount,
+                        },
+                    });
+                }
+                catch {
+                    // success-path diagnostics must never flip a committed sync into failure
+                }
+            }
+            if (options.coexistenceDirection && applyModel.taskRelationships.size > 0) {
+                new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()).runTaskRelationshipCoexistenceTransaction({
+                    tenantId: core.getTenantId(),
+                    workspaceId,
+                    now: now().toISOString(),
+                    apply: (activeRelationshipIds) => applyTaskRelationshipSyncChanges({
+                        core,
+                        workspaceId,
+                        relationships: applyModel.taskRelationships,
+                        protectedRelationshipIds: new Set(activeRelationshipIds),
+                        recordSyncDiagnostic,
+                    }),
+                });
+            }
+            else {
+                applyTaskRelationshipSyncChanges({
+                    core,
+                    workspaceId,
+                    relationships: applyModel.taskRelationships,
+                    recordSyncDiagnostic,
+                });
+            }
+            const deleteCount = applyTaskSyncDeletes({
+                core,
+                workspaceId,
+                taskMutations: applyModel.taskMutations,
+                recordSyncDiagnostic,
+            });
+            applyTaskActivitySyncChanges({
+                core,
+                workspaceId,
+                incomingTaskEvents: applyModel.taskActivity.incomingTaskEvents,
+                recordSyncDiagnostic,
+                createSyncRouteError,
+            });
+            return { result, deleteCount, emittedEventIds: Array.from(emittedEventIds) };
+        }
+        finally {
+            unsubscribeRealtime();
+        }
+    };
+    const applyPreparedContentPhase = (workspaceId, preparedChanges, options, phase) => {
+        if (preparedChanges.length === 0)
+            return;
+        const contentVersionStore = dependencies.contentVersionStore;
+        const contentLifecycle = dependencies.contentLifecycle;
+        if (!contentVersionStore || !contentLifecycle) {
+            throw createSyncRouteError('Prepared V2 content apply requires immutable content lifecycle services.', { source: 'apply.preparedContent.dependencies' }, { code: 'SYNC_V2_CONTENT_LIFECYCLE_REQUIRED', statusCode: 500 });
+        }
+        const changedPaths = [];
+        const resolveNewestDocumentMetadata = (watermark, asset) => {
+            if (!watermark) {
+                return asset
+                    ? { updatedAt: asset.updatedAt, contentHash: asset.contentSha256 }
+                    : null;
+            }
+            if (!asset)
+                return watermark;
+            return resolveSyncConflictOrdering(asset.updatedAt, watermark.updatedAt, asset.contentSha256, watermark.contentHash) >= 0
+                ? { updatedAt: asset.updatedAt, contentHash: asset.contentSha256 }
+                : watermark;
+        };
+        for (const prepared of preparedChanges) {
+            if (phase === 'upserts' && prepared.preparedKind === 'document-upsert') {
+                const { change, version } = prepared;
+                contentVersionStore.lockLogicalHead({
+                    tenantId: version.tenantId,
+                    workspaceId,
+                    kind: 'document',
+                    logicalPath: version.logicalPath,
+                }, now().toISOString());
+                const existingWatermark = core.getDocumentWatermark(workspaceId, change.path);
+                const existingAsset = workspaceAssetStore?.getByStorageKey(change.path, workspaceId) || null;
+                const newestMetadata = resolveNewestDocumentMetadata(existingWatermark, existingAsset);
+                const existingUpdatedAt = String(newestMetadata?.updatedAt || '').trim();
+                const existingHash = String(newestMetadata?.contentHash || '').trim();
+                const compare = resolveSyncConflictOrdering(version.sourceUpdatedAt, existingUpdatedAt, version.contentSha256, existingHash);
+                const metadataDrift = contentSyncState.hasDocumentSyncMetadataDrift(workspaceId, { ...change, content: '' }, options);
+                const replacesExternalPlaceholder = metadataDrift
+                    && existingAsset?.storageProvider === 'external'
+                    && Boolean(change.assetId && change.assetId !== existingAsset.assetId)
+                    && Date.parse(version.sourceUpdatedAt) === Date.parse(existingUpdatedAt);
+                if (compare < 0 && !replacesExternalPlaceholder)
+                    continue;
+                const priorHead = contentVersionStore.getHead({
+                    tenantId: version.tenantId,
+                    workspaceId,
+                    kind: 'document',
+                    logicalPath: version.logicalPath,
+                });
+                const published = contentVersionStore.publish({
+                    tenantId: version.tenantId,
+                    workspaceId,
+                    versionId: version.versionId,
+                    kind: 'document',
+                    logicalPath: version.logicalPath,
+                    sourceUpdatedAt: version.sourceUpdatedAt,
+                    publishedAt: now().toISOString(),
+                });
+                if (published.versionId !== version.versionId || published.deletedAt !== null)
+                    continue;
+                if (compare === 0
+                    && existingHash === version.contentSha256
+                    && !metadataDrift) {
+                    if (priorHead?.versionId !== version.versionId || priorHead.deletedAt !== null) {
+                        changedPaths.push(version.logicalPath);
+                    }
+                    continue;
+                }
+                contentSyncState.persistWorkspaceSyncDocumentMetadata(change, workspaceId, {
+                    contentSha256: version.contentSha256,
+                    sizeBytes: version.sizeBytes,
+                    storageProvider: version.storageProvider,
+                    allowReferenceNumberReassignment: options.allowReferenceNumberReassignment === true
+                        || existingHash !== version.contentSha256
+                        || metadataDrift,
+                    strictWatermark: true,
+                    strictOrdering: true,
+                });
+                changedPaths.push(version.logicalPath);
+                continue;
+            }
+            if (phase === 'upserts' && prepared.preparedKind === 'asset-upsert') {
+                const { change, version } = prepared;
+                contentVersionStore.lockLogicalHead({
+                    tenantId: version.tenantId,
+                    workspaceId,
+                    kind: 'asset',
+                    logicalPath: version.logicalPath,
+                }, now().toISOString());
+                const existing = workspaceAssetStore?.getByStorageKey(change.path, workspaceId) || null;
+                const existingUpdatedAt = String(existing?.updatedAt || '').trim();
+                const existingHash = String(existing?.contentSha256 || '').trim();
+                const compare = resolveSyncConflictOrdering(version.sourceUpdatedAt, existingUpdatedAt, version.contentSha256, existingHash);
+                const metadataDrift = contentSyncState.hasBinaryAssetSyncMetadataDrift(workspaceId, { ...change, contentBase64: '' }, options);
+                if (compare < 0)
+                    continue;
+                const priorHead = contentVersionStore.getHead({
+                    tenantId: version.tenantId,
+                    workspaceId,
+                    kind: 'asset',
+                    logicalPath: version.logicalPath,
+                });
+                const published = contentVersionStore.publish({
+                    tenantId: version.tenantId,
+                    workspaceId,
+                    versionId: version.versionId,
+                    kind: 'asset',
+                    logicalPath: version.logicalPath,
+                    sourceUpdatedAt: version.sourceUpdatedAt,
+                    publishedAt: now().toISOString(),
+                });
+                if (published.versionId !== version.versionId || published.deletedAt !== null)
+                    continue;
+                if (compare === 0
+                    && existingHash === version.contentSha256
+                    && !metadataDrift) {
+                    if (priorHead?.versionId !== version.versionId || priorHead.deletedAt !== null) {
+                        changedPaths.push(version.logicalPath);
+                    }
+                    continue;
+                }
+                contentSyncState.persistWorkspaceSyncBinaryAssetMetadata(change, workspaceId, {
+                    contentSha256: version.contentSha256,
+                    sizeBytes: version.sizeBytes,
+                    storageProvider: version.storageProvider,
+                    allowReferenceNumberReassignment: options.allowReferenceNumberReassignment === true
+                        || existingHash !== version.contentSha256
+                        || metadataDrift,
+                    strictOrdering: true,
+                });
+                changedPaths.push(version.logicalPath);
+                continue;
+            }
+            if (phase !== 'deletes' || prepared.preparedKind !== 'content-delete')
+                continue;
+            const { intent } = prepared;
+            contentVersionStore.lockLogicalHead({
+                tenantId: intent.tenantId,
+                workspaceId,
+                kind: intent.kind,
+                logicalPath: intent.logicalPath,
+            }, now().toISOString());
+            const existing = intent.kind === 'document'
+                ? resolveNewestDocumentMetadata(core.getDocumentWatermark(workspaceId, intent.logicalPath), workspaceAssetStore?.getByStorageKey(intent.logicalPath, workspaceId) || null)
+                : workspaceAssetStore?.getByStorageKey(intent.logicalPath, workspaceId) || null;
+            const existingUpdatedAt = String(existing?.updatedAt || '').trim();
+            const existingHash = String('contentHash' in (existing || {}) ? existing.contentHash : '').trim() || String('contentSha256' in (existing || {}) ? existing.contentSha256 : '').trim();
+            const compare = resolveSyncConflictOrdering(intent.sourceUpdatedAt, existingUpdatedAt, `delete:${intent.logicalPath}`, existingHash);
+            if (existing && compare < 0)
+                continue;
+            if (intent.kind === 'asset'
+                && !contentSyncState.canDeleteWorkspaceSyncBinaryAssetMetadata(intent.logicalPath, workspaceId))
+                continue;
+            const tombstone = contentLifecycle.tombstone({
+                tenantId: intent.tenantId,
+                workspaceId,
+                kind: intent.kind,
+                logicalPath: intent.logicalPath,
+                sourceUpdatedAt: intent.sourceUpdatedAt,
+                publishedAt: now().toISOString(),
+                deletedAt: intent.sourceUpdatedAt,
+            });
+            if (tombstone.versionId !== null
+                || tombstone.sourceUpdatedAt !== intent.sourceUpdatedAt
+                || tombstone.deletedAt !== intent.sourceUpdatedAt)
+                continue;
+            if (intent.kind === 'document') {
+                contentSyncState.deleteWorkspaceSyncDocumentMetadata(intent.logicalPath, workspaceId, intent.sourceUpdatedAt);
+            }
+            else {
+                contentSyncState.deleteWorkspaceSyncBinaryAssetMetadata(intent.logicalPath, workspaceId, intent.sourceUpdatedAt);
+            }
+            changedPaths.push(intent.logicalPath);
+        }
+        if (changedPaths.length > 0) {
+            core.notifyDocumentMetadataMutation(workspaceId, changedPaths, phase === 'upserts' ? 'upsert' : 'delete');
+        }
+    };
+    const lockPreparedContentDomains = (workspaceId, preparedChanges) => {
+        if (preparedChanges.length === 0)
+            return;
+        const contentVersionStore = dependencies.contentVersionStore;
+        if (!contentVersionStore) {
+            throw createSyncRouteError('Prepared V2 content apply requires immutable content lifecycle services.', { source: 'apply.preparedContent.dependencies' }, { code: 'SYNC_V2_CONTENT_LIFECYCLE_REQUIRED', statusCode: 500 });
+        }
+        const domains = new Map();
+        for (const prepared of preparedChanges) {
+            const kind = prepared.preparedKind === 'content-delete'
+                ? prepared.intent.kind
+                : prepared.version.kind;
+            const logicalPath = prepared.preparedKind === 'content-delete'
+                ? prepared.intent.logicalPath
+                : prepared.version.logicalPath;
+            domains.set(`${kind}\u0000${logicalPath}`, { kind, logicalPath });
+        }
+        for (const [, domain] of Array.from(domains.entries()).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))) {
+            contentVersionStore.lockLogicalHead({
+                tenantId: core.getTenantId(),
+                workspaceId,
+                kind: domain.kind,
+                logicalPath: domain.logicalPath,
+            }, now().toISOString());
+        }
+    };
+    const dispatchAtomically = (workspaceId, incomingChanges, options, preparedContentChanges) => {
+        const emittedEventIds = new Set();
+        const unsubscribeRealtime = core.onRealtimeMutation((event) => {
+            const eventWorkspaceId = String(event?.workspaceId || '').trim();
+            if (eventWorkspaceId !== workspaceId)
+                return;
+            const eventId = String(event?.eventId || '').trim();
+            if (eventId)
+                emittedEventIds.add(eventId);
+        });
+        const taxonomyMetaBefore = workspaceTaxonomySyncMeta.get(workspaceId);
+        let sideEffectBatch = null;
+        let committed = false;
+        try {
+            sideEffectBatch = core.beginWorkspaceSyncSideEffectBatch();
+            const atomicResult = core.getDatabaseAdapter().transaction(() => {
+                const { applyModel, taskMutationsForApply, v2ExcludedProjections, } = classifyAndPrepareTaskCarriers(workspaceId, incomingChanges, options, true);
+                const beforeApplyResult = options.transactionHooks?.beforeApply?.();
+                assertSynchronousTransactionResult(beforeApplyResult);
+                lockPreparedContentDomains(workspaceId, preparedContentChanges);
+                applyTaxonomySyncChanges({
+                    core,
+                    workspaceId,
+                    incomingTaxonomies: applyModel.planning.incomingTaxonomies,
+                    incomingTaxonomyState: applyModel.planning.incomingTaxonomyState,
+                    incomingTaxonomiesUpdatedAt: applyModel.planning.incomingTaxonomiesUpdatedAt,
+                    incomingDurableRevision: applyModel.planning.incomingTaxonomyDurableRevision,
+                    workspaceTaxonomySyncMeta,
+                    coexistenceDirection: options.coexistenceDirection,
+                    assertedActiveV3Taxonomy: options.assertedActiveV3Taxonomy,
+                });
+                applyAiProfileAndMemberSyncChanges({
+                    core,
+                    workspaceId,
+                    incomingAiProfiles: applyModel.profiles.incomingAiProfiles,
+                    workspaceMembers: options.workspaceMembers,
+                    recordSyncDiagnostic,
+                    assertSyncedAiProfilesPersisted,
+                    createSyncRouteError,
+                });
+                const preparedTaskSnapshot = prepareTaskSnapshotForDispatch(workspaceId, taskMutationsForApply, v2ExcludedProjections, options);
+                applyPreparedContentPhase(workspaceId, preparedContentChanges, options, 'upserts');
+                applyPlanningSyncChanges({
+                    core,
+                    workspaceId,
+                    incomingInitiatives: applyModel.planning.incomingInitiatives,
+                    incomingWorkstreams: applyModel.planning.incomingWorkstreams,
+                    incomingIdentities: applyModel.planning.incomingIdentities,
+                    recordSyncDiagnostic,
+                    ...(options.coexistenceDirection ? {
+                        coexistenceDirection: options.coexistenceDirection,
+                        assertedActiveV3InitiativeIds: options.assertedActiveV3InitiativeIds,
+                        requiredInitiativeProjectionOwner: options.coexistenceDirection === 'local-pull' ? 'v2' : undefined,
+                        durabilityStore: new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()),
+                        tenantId: core.getTenantId(),
+                        now: now().toISOString(),
+                    } : {}),
+                });
+                applyPreparedContentPhase(workspaceId, preparedContentChanges, options, 'deletes');
+                applyCollaborationSyncChanges({
+                    core,
+                    workspaceId,
+                    incomingDocumentReviewSessions: applyModel.collaboration.incomingDocumentReviewSessions,
+                    incomingDocumentReviewSessionDeletes: applyModel.collaboration.incomingDocumentReviewSessionDeletes,
+                    incomingDocumentReviewComments: applyModel.collaboration.incomingDocumentReviewComments,
+                    incomingDocumentReviewCommentDeletes: applyModel.collaboration.incomingDocumentReviewCommentDeletes,
+                    incomingAnnotatedAttachmentSessions: applyModel.collaboration.incomingAnnotatedAttachmentSessions,
+                    incomingAnnotatedAttachmentSessionDeletes: applyModel.collaboration.incomingAnnotatedAttachmentSessionDeletes,
+                    incomingTaskforceAgents: applyModel.collaboration.incomingTaskforceAgents,
+                    incomingAgentRoles: applyModel.collaboration.incomingAgentRoles,
+                    incomingTaskforceAgentSkills: applyModel.collaboration.incomingTaskforceAgentSkills,
+                    incomingAgentConversations: applyModel.collaboration.incomingAgentConversations,
+                    recordSyncDiagnostic,
+                    createSyncRouteError,
+                });
+                const finalPreparedTaskSnapshot = options.coexistenceDirection && taskMutationsForApply.upserts.length > 0
+                    ? (() => {
+                        const durabilityStore = new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter());
+                        const revisionNow = now().toISOString();
+                        return durabilityStore.runTaskMetadataCoexistenceTransaction({
+                            tenantId: core.getTenantId(),
+                            workspaceId,
+                            direction: options.coexistenceDirection,
+                            taskIds: taskMutationsForApply.upserts.map((mutation) => mutation.task.id),
+                            now: revisionNow,
+                            apply: (ownership) => {
+                                if (options.coexistenceDirection === 'cloud-push'
+                                    && taskMutationsForApply.upserts.some((mutation) => mutation.durableRevision))
+                                    throw new Error('Task durable revisions are only accepted from the cloud pull feed.');
+                                const durablePull = options.coexistenceDirection === 'local-pull'
+                                    ? prepareDurableTaskPullMutations({
+                                        store: durabilityStore,
+                                        tenantId: core.getTenantId(),
+                                        workspaceId,
+                                        taskMutations: taskMutationsForApply,
+                                    })
+                                    : { taskMutations: taskMutationsForApply, pendingRevisions: [] };
+                                const prepared = prepareTaskSyncSnapshotApply({
+                                    core,
+                                    workspaceId,
+                                    taskMutations: durablePull.taskMutations,
+                                    recordSyncDiagnostic,
+                                    ...(v2ExcludedProjections.has('task/root-v1') ? {
+                                        v3OwnedTaskRootIds: new Set(durablePull.taskMutations.upserts.map((mutation) => mutation.task.id)),
+                                    } : {}),
+                                    v3OwnedTaskMetadataIds: resolveV3OwnedTaskMetadataIds({
+                                        direction: options.coexistenceDirection,
+                                        assertedActiveTaskIds: options.assertedActiveV3TaskMetadataIds,
+                                        ownership,
+                                    }),
+                                    v3OwnedTaskTaxonomyIds: resolveV3OwnedTaskTaxonomyIds({
+                                        direction: options.coexistenceDirection,
+                                        ownership: durabilityStore.listTaskTaxonomyProjectionOwnership({
+                                            tenantId: core.getTenantId(),
+                                            workspaceId,
+                                            taskIds: taskMutationsForApply.upserts.map((mutation) => mutation.task.id),
+                                        }),
+                                    }),
+                                    v3OwnedTaskDeleteIds: resolveV3OwnedTaskDeleteIds({
+                                        direction: options.coexistenceDirection,
+                                        assertedActiveTaskIds: options.assertedActiveV3TaskDeleteIds,
+                                        ownership,
+                                    }),
+                                    v3OwnedTaskLifecycleIds: resolveV3OwnedTaskLifecycleIds({
+                                        direction: options.coexistenceDirection,
+                                        assertedActiveTaskIds: options.assertedActiveV3TaskLifecycleIds,
+                                        ownership,
+                                    }),
+                                    v3OwnedTaskReopenAssigneeIds: resolveV3OwnedTaskReopenAssigneeIds({
+                                        direction: options.coexistenceDirection,
+                                        assertedActiveTaskIds: options.assertedActiveV3TaskReopenAssigneeIds,
+                                        ownership,
+                                    }),
+                                    coexistenceDirection: options.coexistenceDirection,
+                                    recordReferenceNumberMismatch: false,
+                                });
+                                validateTaskActorAssignments(workspaceId, prepared.tasks, prepared.archived);
+                                const result = applyPreparedTaskSyncSnapshot({
+                                    core,
+                                    workspaceId,
+                                    prepared,
+                                    deferSideEffects: true,
+                                });
+                                applyDurableTaskPullRevisions({
+                                    store: durabilityStore,
+                                    tenantId: core.getTenantId(),
+                                    workspaceId,
+                                    revisions: durablePull.pendingRevisions,
+                                    now: revisionNow,
+                                });
+                                return { prepared, result };
+                            },
+                        });
+                    })()
+                    : {
+                        prepared: preparedTaskSnapshot,
+                        result: applyPreparedTaskSyncSnapshot({
+                            core,
+                            workspaceId,
+                            prepared: preparedTaskSnapshot,
+                            deferSideEffects: true,
+                        }),
+                    };
+                const protectedTaskCount = finalPreparedTaskSnapshot.prepared.metadataPreservedTaskIds.length;
+                const protectedLifecycleTaskCount = finalPreparedTaskSnapshot.prepared.lifecyclePreservedTaskIds.length;
+                const seededTaskCount = finalPreparedTaskSnapshot.prepared.metadataSeededTaskIds.length;
+                if ((protectedTaskCount > 0 || protectedLifecycleTaskCount > 0 || seededTaskCount > 0)
+                    && options.coexistenceDirection) {
+                    try {
+                        core.recordSyncEvent(workspaceId, {
+                            eventType: 'apply',
+                            status: 'success',
+                            changeCount: protectedTaskCount + protectedLifecycleTaskCount + seededTaskCount,
+                            requestMs: 0,
+                            details: {
+                                source: 'apply.taskMetadataCoexistenceFirewall',
+                                direction: options.coexistenceDirection,
+                                protectedTaskCount,
+                                protectedLifecycleTaskCount,
+                                seededTaskCount,
+                            },
+                        });
+                    }
+                    catch {
+                        // Success-path diagnostics must not fail the authoritative apply.
+                    }
+                }
+                if (options.coexistenceDirection && applyModel.taskRelationships.size > 0) {
+                    new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter()).runTaskRelationshipCoexistenceTransaction({
+                        tenantId: core.getTenantId(),
+                        workspaceId,
+                        now: now().toISOString(),
+                        apply: (activeRelationshipIds) => applyTaskRelationshipSyncChanges({
+                            core,
+                            workspaceId,
+                            relationships: applyModel.taskRelationships,
+                            protectedRelationshipIds: new Set(activeRelationshipIds),
+                            recordSyncDiagnostic,
+                        }),
+                    });
+                }
+                else {
+                    applyTaskRelationshipSyncChanges({
+                        core,
+                        workspaceId,
+                        relationships: applyModel.taskRelationships,
+                        recordSyncDiagnostic,
+                    });
+                }
+                const deleteCount = applyTaskSyncDeletes({
+                    core,
+                    workspaceId,
+                    taskMutations: applyModel.taskMutations,
+                    recordSyncDiagnostic,
+                    failFast: true,
+                });
+                applyTaskActivitySyncChanges({
+                    core,
+                    workspaceId,
+                    incomingTaskEvents: applyModel.taskActivity.incomingTaskEvents,
+                    recordSyncDiagnostic,
+                    createSyncRouteError,
+                });
+                const result = {
+                    result: finalPreparedTaskSnapshot.result,
+                    deleteCount,
+                    emittedEventIds: [],
+                };
+                const beforeCommitResult = options.transactionHooks?.beforeCommit?.(result);
+                assertSynchronousTransactionResult(beforeCommitResult);
+                return {
+                    result,
+                    committedTaskIds: finalPreparedTaskSnapshot.result.changedTaskIds || [],
+                };
+            })();
+            committed = true;
+            if (atomicResult.committedTaskIds.length > 0) {
+                try {
+                    core.notifyWorkspaceSyncSnapshotCommitted(workspaceId, atomicResult.committedTaskIds);
+                }
+                catch (error) {
+                    recordSyncDiagnostic(workspaceId, 'apply', 'Failed to publish committed workspace task snapshot side effects.', {
+                        source: 'apply.taskSnapshotPostCommit',
+                        taskCount: atomicResult.committedTaskIds.length,
+                        error: String(error?.message || error || 'Unknown post-commit failure'),
+                    });
+                }
+            }
+            try {
+                sideEffectBatch.commit();
+            }
+            catch (error) {
+                recordSyncDiagnostic(workspaceId, 'apply', 'Failed to publish committed workspace sync side effects.', {
+                    source: 'apply.atomicSideEffectBatchCommit',
+                    error: String(error?.message || error || 'Unknown post-commit failure'),
+                });
+            }
+            atomicResult.result.emittedEventIds.push(...emittedEventIds);
+            return atomicResult.result;
+        }
+        catch (error) {
+            if (!committed) {
+                if (taxonomyMetaBefore) {
+                    workspaceTaxonomySyncMeta.set(workspaceId, taxonomyMetaBefore);
+                }
+                else {
+                    workspaceTaxonomySyncMeta.delete(workspaceId);
+                }
+                try {
+                    sideEffectBatch?.rollback();
+                }
+                catch {
+                    // Preserve the mutation failure that caused the database rollback.
+                }
+            }
+            throw error;
+        }
+        finally {
+            unsubscribeRealtime();
+        }
+    };
+    const dispatchMetadataAtomically = (workspaceId, incomingChanges, options = {}) => {
+        return dispatchAtomically(workspaceId, incomingChanges, options, []);
+    };
+    const dispatchPreparedContentAtomically = (workspaceId, plan, options = {}) => {
+        if (!plan || !Array.isArray(plan.changes)) {
+            throw createSyncRouteError('Prepared V2 content plan is invalid.', { source: 'apply.preparedContent.plan' }, { code: 'SYNC_V2_PREPARED_CONTENT_INVALID', statusCode: 400 });
+        }
+        const nonContentChanges = [];
+        const preparedContentChanges = [];
+        for (const change of plan.changes) {
+            if ('preparedKind' in change) {
+                const identity = change.preparedKind === 'content-delete'
+                    ? change.intent
+                    : change.version;
+                const changePath = String(change.change.path || '').trim();
+                if (identity.tenantId !== core.getTenantId()
+                    || identity.workspaceId !== workspaceId
+                    || identity.logicalPath !== changePath) {
+                    throw createSyncRouteError('Prepared V2 content identity does not match the apply scope.', { source: 'apply.preparedContent.identity' }, { code: 'SYNC_V2_PREPARED_CONTENT_SCOPE_MISMATCH', statusCode: 409 });
+                }
+                preparedContentChanges.push(change);
+            }
+            else {
+                nonContentChanges.push(change);
+            }
+        }
+        if (preparedContentChanges.length > 0 && !workspaceAssetStore) {
+            throw createSyncRouteError('Prepared V2 content apply requires the canonical workspace asset store.', { source: 'apply.preparedContent.assetStore' }, { code: 'SYNC_V2_CONTENT_ASSET_STORE_REQUIRED', statusCode: 500 });
+        }
+        return dispatchAtomically(workspaceId, nonContentChanges, options, preparedContentChanges);
+    };
+    return { dispatch, dispatchMetadataAtomically, dispatchPreparedContentAtomically };
+}