@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/sync/syncApplyHandlers.js

@@ -1,23 +1,39 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createHash } from 'crypto';
+import { assertPlanningIdentityColor, assertPlanningIdentityIcon } from '../shared/planningIdentity.js';
+import { parseAiProfileColorSource } from '../shared/aiProfileColors.js';
 import { normalizeBinaryAssetDeleteSyncPayload, normalizeBinaryAssetSyncPayload, normalizeDocumentDeleteSyncPayload, normalizeDocumentSyncPayload, } from './contentSyncPayload.js';
-import { normalizeAiProfileSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDeleteSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, } from './collaborationSyncPayload.js';
+import { normalizeAiProfileSyncPayload, normalizeAgentConversationSyncPayload, normalizeAgentRoleSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDeleteSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, normalizeTaskforceAgentSkillSyncPayload, normalizeTaskforceAgentSyncPayload, } from './collaborationSyncPayload.js';
 import { normalizeInitiativeSyncPayload, normalizeTaxonomySyncPayload, normalizeWorkstreamSyncPayload, } from './planningSyncPayload.js';
 import { normalizeTaskSyncPayload, taskSyncPayloadToCoreTask, } from './taskSyncPayload.js';
 import { compareWorkspaceMutationOrdering, getTaskMutationTieBreak, getTaskMutationWatermark } from './workspaceSyncSurface.js';
+import { isTaskMetadataActivityEventId } from './v3/taskMetadataActivityIdentity.js';
+import { fingerprintWorkspaceSyncPayload, WorkspaceSyncRevisionConflictError, WorkspaceSyncDurabilityStore, } from './v3/syncDurabilityStore.js';
+import { runTaxonomyCoexistenceTransaction } from './v3/taxonomyCoexistence.js';
+import { applyInitiativeSyncChangesWithCoexistence } from './v3/initiativeCoexistence.js';
+import { applyWorkstreamSyncChangesWithCoexistence } from './v3/workstreamCoexistence.js';
+import { serializeTaxonomyStateForSync } from './v3/taxonomySyncPayload.js';
+import { TaskforceAgentStore } from '../storage/taskforceAgentStore.js';
+import { TaskforceAgentSkillStore } from '../storage/taskforceAgentSkillStore.js';
+import { TaskforceAgentConversationStore } from '../storage/taskforceAgentConversationStore.js';
+import { AgentRoleStore } from '../storage/agentRoleStore.js';
+import { preserveV3OwnedTaskRoot, preserveV3OwnedTaskLifecycle, preserveV3OwnedTaskMetadata, preserveV3OwnedTaskReopenAssignee, preserveV3OwnedTaskTaxonomy, } from './v3/taskMetadataCoexistence.js';
 function createIncomingApplyModel() {
     return {
         taskMutations: {
             upserts: [],
             deletes: new Map(),
         },
+        taskRelationships: new Map(),
         planning: {
             incomingTaxonomies: null,
             incomingTaxonomyState: null,
             incomingTaxonomiesUpdatedAt: '',
+            incomingTaxonomyDurableRevision: null,
             incomingInitiatives: new Map(),
             incomingWorkstreams: new Map(),
+            incomingIdentities: new Map(),
         },
         profiles: {
             incomingAiProfiles: new Map(),
@@ -35,6 +51,10 @@ function createIncomingApplyModel() {
             incomingDocumentReviewCommentDeletes: new Map(),
             incomingAnnotatedAttachmentSessions: new Map(),
             incomingAnnotatedAttachmentSessionDeletes: new Map(),
+            incomingTaskforceAgents: new Map(),
+            incomingAgentRoles: new Map(),
+            incomingTaskforceAgentSkills: new Map(),
+            incomingAgentConversations: new Map(),
         },
         taskActivity: {
             incomingTaskEvents: new Map(),
@@ -46,8 +66,11 @@ export function resolveSyncConflictOrdering(incomingWatermark, existingWatermark
 }
 function shouldSkipTaskClassification(op) {
     return (op === 'delete'
+        || op === 'task-relationship-upsert'
+        || op === 'task-relationship-delete'
         || op === 'initiative-upsert'
         || op === 'workstream-upsert'
+        || op === 'planning-identity-upsert'
         || op === 'document-upsert'
         || op === 'document-delete'
         || op === 'asset-upsert'
@@ -57,7 +80,41 @@ function shouldSkipTaskClassification(op) {
         || op === 'document-review-comment-upsert'
         || op === 'document-review-comment-delete'
         || op === 'annotated-attachment-session-upsert'
-        || op === 'annotated-attachment-session-delete');
+        || op === 'annotated-attachment-session-delete'
+        || op === 'taskforce-agent-upsert'
+        || op === 'agent-role-upsert'
+        || op === 'taskforce-agent-skill-upsert'
+        || op === 'agent-conversation-upsert');
+}
+function normalizeDurableTaskRevision(raw, task) {
+    if (raw === undefined)
+        return null;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error('Task durable revision must be an object.');
+    }
+    const source = raw;
+    const expectedKeys = [
+        'canonicalFingerprint', 'contractVersion', 'domain', 'entityId', 'entityRevision',
+        'lifecycleRevision', 'mutationKind', 'payloadFingerprint', 'sequence', 'taxonomyOwned',
+    ].sort();
+    const actualKeys = Object.keys(source).sort();
+    if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index) => key !== expectedKeys[index])) {
+        throw new Error('Task durable revision contains missing or unknown fields.');
+    }
+    if (source.contractVersion !== 3
+        || source.domain !== 'task'
+        || source.entityId !== task.id
+        || source.mutationKind !== 'replicated-state'
+        || typeof source.sequence !== 'string' || !/^[1-9]\d*$/.test(source.sequence)
+        || typeof source.entityRevision !== 'string' || !/^[1-9]\d*$/.test(source.entityRevision)
+        || typeof source.lifecycleRevision !== 'string' || !/^(0|[1-9]\d*)$/.test(source.lifecycleRevision)
+        || typeof source.canonicalFingerprint !== 'string' || !/^[a-f0-9]{64}$/.test(source.canonicalFingerprint)
+        || typeof source.payloadFingerprint !== 'string' || !/^[a-f0-9]{64}$/.test(source.payloadFingerprint)
+        || typeof source.taxonomyOwned !== 'boolean'
+        || fingerprintWorkspaceSyncPayload(task) !== source.payloadFingerprint) {
+        throw new Error('Task durable revision does not match its task payload.');
+    }
+    return source;
 }
 function recordTaskReferenceNumberMismatch(input) {
     const { core, workspaceId, task, recordSyncDiagnostic, } = input;
@@ -88,14 +145,35 @@ export function classifyWorkspaceSyncChanges(input) {
     for (const change of incomingChanges) {
         const raw = change;
         const op = String(raw.op || '').trim().toLowerCase();
+        if (op === 'task-relationship-upsert' || op === 'task-relationship-delete') {
+            const value = raw.relationship;
+            const id = String(value?.id || '').trim();
+            const sourceTaskId = String(value?.sourceTaskId || '').trim();
+            const targetTaskId = String(value?.targetTaskId || '').trim();
+            const kind = String(value?.kind || '').trim();
+            const updatedAt = String(value?.updatedAt || '').trim();
+            if (id && sourceTaskId && targetTaskId && ['dependency', 'related', 'supersedes'].includes(kind) && Number.isFinite(Date.parse(updatedAt))) {
+                model.taskRelationships.set(id, {
+                    id, workspaceId, sourceTaskId, targetTaskId,
+                    kind: kind,
+                    createdBy: value?.createdBy || null,
+                    createdAt: String(value?.createdAt || updatedAt),
+                    updatedBy: value?.updatedBy || null,
+                    updatedAt,
+                    deletedBy: value?.deletedBy || null,
+                    deletedAt: op === 'task-relationship-delete' ? String(value?.deletedAt || updatedAt) : value?.deletedAt || null,
+                });
+            }
+            continue;
+        }
         if (op === 'taxonomy-upsert') {
             const taxonomy = normalizeTaxonomySyncPayload(raw);
-            if (taxonomy?.taxonomyState)
-                model.planning.incomingTaxonomyState = taxonomy.taxonomyState;
-            if (Array.isArray(taxonomy?.taxonomies))
-                model.planning.incomingTaxonomies = taxonomy.taxonomies;
-            if (taxonomy?.updatedAt)
+            if (taxonomy) {
+                model.planning.incomingTaxonomyState = taxonomy.taxonomyState || null;
+                model.planning.incomingTaxonomies = Array.isArray(taxonomy.taxonomies) ? taxonomy.taxonomies : null;
                 model.planning.incomingTaxonomiesUpdatedAt = taxonomy.updatedAt;
+                model.planning.incomingTaxonomyDurableRevision = taxonomy.durableRevision || null;
+            }
             continue;
         }
         if (op === 'initiative-upsert') {
@@ -110,6 +188,26 @@ export function classifyWorkspaceSyncChanges(input) {
                 model.planning.incomingWorkstreams.set(workstream.id, workstream);
             continue;
         }
+        if (op === 'planning-identity-upsert') {
+            const value = raw.identity;
+            const entityType = value?.entityType === 'initiative' || value?.entityType === 'workstream'
+                ? value.entityType
+                : null;
+            const entityId = String(value?.entityId || '').trim();
+            const updatedAt = String(value?.updatedAt || raw.updatedAt || raw.watermark || '').trim();
+            if (!entityType || !entityId || !Number.isFinite(Date.parse(updatedAt))) {
+                throw new Error('Planning identity sync payload is invalid.');
+            }
+            const identity = {
+                entityType,
+                entityId,
+                icon: assertPlanningIdentityIcon(value?.icon),
+                color: assertPlanningIdentityColor(value?.color),
+                updatedAt,
+            };
+            model.planning.incomingIdentities.set(`${entityType}:${entityId}`, identity);
+            continue;
+        }
         if (op === 'ai-profile-upsert') {
             const profile = normalizeAiProfileSyncPayload(raw.profile, workspaceId, normalizeIncomingAiProfileSurfaceType, normalizeIncomingAiProfileSeatScope, 'apply.aiProfileUpsert');
             const profileId = String(profile?.id || '').trim();
@@ -178,8 +276,15 @@ export function classifyWorkspaceSyncChanges(input) {
         }
         if (op === 'document-review-comment-delete') {
             const deletedComment = normalizeDeleteSyncPayload(raw, 'commentId');
-            if (deletedComment)
-                model.collaboration.incomingDocumentReviewCommentDeletes.set(deletedComment.id, deletedComment.deletedAt);
+            if (deletedComment) {
+                const deletedByActorId = typeof raw.deletedByActorId === 'string' && raw.deletedByActorId.trim().length > 0
+                    ? raw.deletedByActorId.trim()
+                    : null;
+                model.collaboration.incomingDocumentReviewCommentDeletes.set(deletedComment.id, {
+                    deletedAt: deletedComment.deletedAt,
+                    deletedByActorId,
+                });
+            }
             continue;
         }
         if (op === 'annotated-attachment-session-upsert') {
@@ -194,6 +299,30 @@ export function classifyWorkspaceSyncChanges(input) {
                 model.collaboration.incomingAnnotatedAttachmentSessionDeletes.set(deletedSession.id, deletedSession.deletedAt);
             continue;
         }
+        if (op === 'taskforce-agent-upsert') {
+            const agent = normalizeTaskforceAgentSyncPayload(raw.agent, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
+            if (agent)
+                model.collaboration.incomingTaskforceAgents.set(agent.id, agent);
+            continue;
+        }
+        if (op === 'agent-role-upsert') {
+            const role = normalizeAgentRoleSyncPayload(raw.role, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
+            if (role)
+                model.collaboration.incomingAgentRoles.set(role.id, role);
+            continue;
+        }
+        if (op === 'taskforce-agent-skill-upsert') {
+            const skill = normalizeTaskforceAgentSkillSyncPayload(raw.skill, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
+            if (skill)
+                model.collaboration.incomingTaskforceAgentSkills.set(skill.id, skill);
+            continue;
+        }
+        if (op === 'agent-conversation-upsert') {
+            const conversation = normalizeAgentConversationSyncPayload(raw.conversation, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
+            if (conversation)
+                model.collaboration.incomingAgentConversations.set(conversation.id, conversation);
+            continue;
+        }
         if (op === 'task-event-upsert' || op === 'entity-event-upsert') {
             const event = normalizeTaskEventSyncPayload(raw.event, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
             if (event)
@@ -205,7 +334,24 @@ export function classifyWorkspaceSyncChanges(input) {
         const task = normalizeTaskSyncPayload(raw.task);
         const deleteTaskId = String(raw.taskId || raw.id || task?.id || '').trim();
         if (deleteTaskId) {
-            model.taskMutations.deletes.set(deleteTaskId, String(raw.deletedAt || raw.watermark || new Date().toISOString()).trim());
+            const actorType = raw.actorType === 'human' || raw.actorType === 'ai' || raw.actorType === 'system'
+                ? raw.actorType
+                : undefined;
+            const source = raw.source === 'ui' || raw.source === 'mcp' || raw.source === 'sync' || raw.source === 'workspace-delete' || raw.source === 'system'
+                ? raw.source
+                : undefined;
+            const details = raw.details && typeof raw.details === 'object' && !Array.isArray(raw.details)
+                ? raw.details
+                : undefined;
+            const suppliedDeletedAt = String(raw.deletedAt || raw.watermark || '').trim();
+            model.taskMutations.deletes.set(deleteTaskId, {
+                deletedAt: suppliedDeletedAt || new Date().toISOString(),
+                suppliedDeletedAt: Boolean(suppliedDeletedAt),
+                ...(raw.actor ? { actor: String(raw.actor) } : {}),
+                ...(actorType ? { actorType } : {}),
+                ...(source ? { source } : {}),
+                ...(details ? { details } : {}),
+            });
         }
     }
     for (const change of incomingChanges) {
@@ -216,52 +362,206 @@ export function classifyWorkspaceSyncChanges(input) {
         const task = normalizeTaskSyncPayload(raw.task);
         if (!task)
             continue;
+        const durableRevision = normalizeDurableTaskRevision(raw.durableRevision, task);
         model.taskMutations.upserts.push({
             archived: raw.archived === true || task.isArchived === true,
             task,
+            ...(durableRevision ? { durableRevision } : {}),
         });
     }
     return model;
 }
 export function prepareTaskSyncSnapshotApply(input) {
-    const { core, workspaceId, taskMutations, recordSyncDiagnostic, } = input;
+    const { core, workspaceId, taskMutations, recordSyncDiagnostic, v3OwnedTaskMetadataIds, v3OwnedTaskRootIds, v3OwnedTaskTaxonomyIds, v3OwnedTaskDeleteIds, v3OwnedTaskLifecycleIds, v3OwnedTaskReopenAssigneeIds, coexistenceDirection, recordReferenceNumberMismatch = true, } = input;
     const prepared = {
         tasks: [],
         archived: [],
+        authoritativeTaskTaxonomyIds: [],
+        authoritativeTaskNestedContentIds: [],
+        metadataPreservedTaskIds: [],
+        metadataSeededTaskIds: [],
+        lifecyclePreservedTaskIds: [],
+        reopenAssigneePreservedTaskIds: [],
     };
     for (const mutation of taskMutations.upserts) {
-        const task = mutation.task;
-        const taskId = String(task.id || '').trim();
-        recordTaskReferenceNumberMismatch({
-            core,
-            workspaceId,
-            task: task,
-            recordSyncDiagnostic,
-        });
-        const deleteWatermark = taskId ? String(taskMutations.deletes.get(taskId) || '').trim() : '';
+        const incomingTask = mutation.task;
+        const taskId = String(incomingTask.id || '').trim();
+        if (taskId && mutation.durableRevision?.taxonomyOwned)
+            prepared.authoritativeTaskTaxonomyIds.push(taskId);
+        if (taskId && v3OwnedTaskRootIds?.has(taskId))
+            prepared.authoritativeTaskNestedContentIds.push(taskId);
+        if (taskId && v3OwnedTaskDeleteIds?.has(taskId))
+            continue;
+        const existing = taskId && (v3OwnedTaskRootIds?.has(taskId) || v3OwnedTaskMetadataIds?.has(taskId) || v3OwnedTaskTaxonomyIds?.has(taskId) || v3OwnedTaskLifecycleIds?.has(taskId) || v3OwnedTaskReopenAssigneeIds?.has(taskId))
+            ? core.getTask(taskId, workspaceId)
+            : null;
+        let task = incomingTask;
+        if (taskId && v3OwnedTaskRootIds?.has(taskId)) {
+            if (!existing) {
+                throw Object.assign(new Error(`V2 task carrier ${taskId} is missing its v3-owned task root.`), { code: 'SYNC_V2_TASK_CARRIER_ROOT_MISSING', statusCode: 409 });
+            }
+            task = preserveV3OwnedTaskRoot(task, existing);
+        }
+        if (existing && v3OwnedTaskMetadataIds?.has(taskId)) {
+            task = preserveV3OwnedTaskMetadata(task, existing);
+            if (coexistenceDirection)
+                prepared.metadataPreservedTaskIds.push(taskId);
+        }
+        if (existing
+            && v3OwnedTaskTaxonomyIds?.has(taskId)
+            && !(coexistenceDirection === 'local-pull' && mutation.durableRevision?.taxonomyOwned)) {
+            task = preserveV3OwnedTaskTaxonomy(task, existing);
+        }
+        if (existing && v3OwnedTaskLifecycleIds?.has(taskId)) {
+            task = preserveV3OwnedTaskLifecycle(task, existing);
+            if (coexistenceDirection)
+                prepared.lifecyclePreservedTaskIds.push(taskId);
+        }
+        if (existing && v3OwnedTaskReopenAssigneeIds?.has(taskId)) {
+            task = preserveV3OwnedTaskReopenAssignee(task, existing);
+            if (coexistenceDirection)
+                prepared.reopenAssigneePreservedTaskIds.push(taskId);
+        }
+        if (!existing
+            && taskId
+            && coexistenceDirection === 'cloud-push'
+            && v3OwnedTaskMetadataIds?.has(taskId)) {
+            // A metadata operation cannot create its missing cloud entity. Seed the
+            // entity once from the same local snapshot; the active assertion keeps
+            // later v2 pushes protected until v3 acceptance records ownership.
+            prepared.metadataSeededTaskIds.push(taskId);
+        }
+        if (recordReferenceNumberMismatch) {
+            recordTaskReferenceNumberMismatch({
+                core,
+                workspaceId,
+                task: task,
+                recordSyncDiagnostic,
+            });
+        }
+        const deleteWatermark = taskId ? String(taskMutations.deletes.get(taskId)?.deletedAt || '').trim() : '';
         if (taskId && deleteWatermark) {
             const compareAgainstDelete = resolveSyncConflictOrdering(deleteWatermark, String(task.updatedAt || task.createdAt || '').trim(), `delete:${taskId}`, getTaskMutationTieBreak(task, mutation.archived));
             if (compareAgainstDelete >= 0)
                 continue;
         }
-        if (mutation.archived)
+        if (task.isArchived === true)
             prepared.archived.push(task);
         else
             prepared.tasks.push(task);
     }
     return prepared;
 }
+export function prepareDurableTaskPullMutations(input) {
+    const upserts = [];
+    const pendingRevisions = [];
+    for (const mutation of input.taskMutations.upserts) {
+        const marker = mutation.durableRevision;
+        if (!marker) {
+            upserts.push(mutation);
+            continue;
+        }
+        const current = input.store.readWorkspaceDomainOwnership({
+            tenantId: input.tenantId,
+            workspaceId: input.workspaceId,
+            domain: 'task',
+            entityId: marker.entityId,
+        });
+        if (current.activeOperation)
+            throw new WorkspaceSyncRevisionConflictError({
+                domain: 'task',
+                entityId: marker.entityId,
+                reason: 'active-local-operation',
+            });
+        const incomingRevision = BigInt(marker.entityRevision);
+        const currentRevision = BigInt(current.entityRevision);
+        if (incomingRevision < currentRevision)
+            continue;
+        if (incomingRevision === currentRevision) {
+            if (current.lifecycleRevision !== marker.lifecycleRevision
+                || current.lastSequence !== marker.sequence
+                || current.canonicalFingerprint !== marker.canonicalFingerprint)
+                throw new WorkspaceSyncRevisionConflictError({
+                    domain: 'task',
+                    entityId: marker.entityId,
+                    reason: 'equal-revision-divergence',
+                    incoming: {
+                        sequence: marker.sequence,
+                        entityRevision: marker.entityRevision,
+                        lifecycleRevision: marker.lifecycleRevision,
+                        canonicalFingerprint: marker.canonicalFingerprint,
+                    },
+                    current,
+                });
+            upserts.push(mutation);
+            pendingRevisions.push(marker);
+            continue;
+        }
+        if (current.lastSequence !== null && BigInt(marker.sequence) <= BigInt(current.lastSequence)) {
+            throw new WorkspaceSyncRevisionConflictError({
+                domain: 'task',
+                entityId: marker.entityId,
+                reason: 'sequence-regression',
+                incoming: {
+                    sequence: marker.sequence,
+                    entityRevision: marker.entityRevision,
+                    lifecycleRevision: marker.lifecycleRevision,
+                    canonicalFingerprint: marker.canonicalFingerprint,
+                },
+                current,
+            });
+        }
+        upserts.push(mutation);
+        pendingRevisions.push(marker);
+    }
+    return {
+        taskMutations: { upserts, deletes: input.taskMutations.deletes },
+        pendingRevisions,
+    };
+}
+export function applyDurableTaskPullRevisions(input) {
+    for (const marker of input.revisions) {
+        input.store.applyReplicatedEntityRevision({
+            tenantId: input.tenantId,
+            workspaceId: input.workspaceId,
+            domain: marker.domain,
+            entityId: marker.entityId,
+            sequence: marker.sequence,
+            entityRevision: marker.entityRevision,
+            lifecycleRevision: marker.lifecycleRevision,
+            canonicalFingerprint: marker.canonicalFingerprint,
+            now: input.now,
+            applyMutation: () => undefined,
+        });
+        if (marker.taxonomyOwned) {
+            input.store.markTaskTaxonomyProjectionOwned({
+                tenantId: input.tenantId,
+                workspaceId: input.workspaceId,
+                taskIds: [marker.entityId],
+                now: input.now,
+            });
+        }
+    }
+}
 export function applyTaskSyncDeletes(input) {
     const { core, workspaceId, taskMutations, recordSyncDiagnostic, } = input;
-    for (const [taskId, deleteWatermark] of taskMutations.deletes.entries()) {
+    for (const [taskId, deletion] of taskMutations.deletes.entries()) {
         try {
+            const deleteWatermark = deletion.deletedAt;
             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 });
+            core.deleteTaskForSync(taskId, workspaceId, {
+                persistBackup: false,
+                ...(deletion.suppliedDeletedAt ? { deletedAt: deletion.deletedAt } : {}),
+                ...(deletion.actor ? { actor: deletion.actor } : {}),
+                ...(deletion.actorType ? { actorType: deletion.actorType } : {}),
+                ...(deletion.source ? { source: deletion.source } : {}),
+                ...(deletion.details ? { details: deletion.details } : {}),
+            });
         }
         catch (error) {
             recordSyncDiagnostic(workspaceId, 'apply', 'Failed to delete task during sync apply.', {
@@ -269,20 +569,79 @@ export function applyTaskSyncDeletes(input) {
                 taskId,
                 error: String(error?.message || error || '')
             });
+            if (input.failFast)
+                throw error;
         }
     }
     return taskMutations.deletes.size;
 }
 export function applyPreparedTaskSyncSnapshot(input) {
-    const { core, workspaceId, prepared, } = input;
-    return core.applyWorkspaceSyncSnapshot({
+    const { core, workspaceId, prepared, deferSideEffects, } = input;
+    const snapshot = {
         tasks: prepared.tasks.map(taskSyncPayloadToCoreTask),
         archived: prepared.archived.map(taskSyncPayloadToCoreTask)
-    }, workspaceId);
+    };
+    const options = {
+        ...(deferSideEffects ? { deferSideEffects: true } : {}),
+        ...(prepared.authoritativeTaskTaxonomyIds.length > 0
+            ? { authoritativeTaskTaxonomyIds: new Set(prepared.authoritativeTaskTaxonomyIds) }
+            : {}),
+        ...(prepared.authoritativeTaskNestedContentIds.length > 0
+            ? { authoritativeTaskNestedContentIds: new Set(prepared.authoritativeTaskNestedContentIds) }
+            : {}),
+    };
+    return Object.keys(options).length > 0
+        ? core.applyWorkspaceSyncSnapshot(snapshot, workspaceId, options)
+        : core.applyWorkspaceSyncSnapshot(snapshot, workspaceId);
+}
+export function applyTaskRelationshipSyncChanges(input) {
+    let applied = 0;
+    let skipped = 0;
+    const ordered = [...input.relationships.values()].sort((left, right) => {
+        if (Boolean(left.deletedAt) !== Boolean(right.deletedAt))
+            return left.deletedAt ? 1 : -1;
+        return left.updatedAt.localeCompare(right.updatedAt) || left.id.localeCompare(right.id);
+    });
+    for (const relationship of ordered) {
+        if (input.protectedRelationshipIds?.has(relationship.id)) {
+            skipped += 1;
+            continue;
+        }
+        try {
+            if (input.core.applyTaskRelationshipForSync(relationship, input.workspaceId) === 'applied')
+                applied += 1;
+            else
+                skipped += 1;
+        }
+        catch (error) {
+            input.recordSyncDiagnostic(input.workspaceId, 'apply', `Rejected task relationship ${relationship.id}: ${String(error?.message || error)}`, {
+                source: 'apply.taskRelationship', relationshipId: relationship.id,
+                sourceTaskId: relationship.sourceTaskId, targetTaskId: relationship.targetTaskId,
+            });
+            throw error;
+        }
+    }
+    return { applied, skipped };
 }
 export function applyPlanningSyncChanges(input) {
-    const { core, workspaceId, incomingInitiatives, incomingWorkstreams, incomingTaxonomies, incomingTaxonomyState, incomingTaxonomiesUpdatedAt, workspaceTaxonomySyncMeta, recordSyncDiagnostic, } = input;
-    if (incomingInitiatives.size > 0) {
+    const { core, workspaceId, incomingInitiatives, incomingWorkstreams, recordSyncDiagnostic, } = input;
+    if (incomingInitiatives.size > 0 && input.coexistenceDirection) {
+        if (!input.durabilityStore || !input.tenantId || !input.now) {
+            throw new Error('Initiative coexistence requires durability store, tenant, and timestamp.');
+        }
+        applyInitiativeSyncChangesWithCoexistence({
+            store: input.durabilityStore,
+            core,
+            tenantId: input.tenantId,
+            workspaceId,
+            direction: input.coexistenceDirection,
+            incomingInitiatives,
+            assertedActiveInitiativeIds: input.assertedActiveV3InitiativeIds,
+            requiredProjectionOwner: input.requiredInitiativeProjectionOwner,
+            now: input.now,
+        });
+    }
+    else if (incomingInitiatives.size > 0) {
         for (const initiative of incomingInitiatives.values()) {
             try {
                 core.upsertInitiativeForSync({
@@ -292,6 +651,7 @@ export function applyPlanningSyncChanges(input) {
                     title: initiative.title,
                     description: initiative.description,
                     ownerId: initiative.ownerId,
+                    ...(initiative.comments !== undefined ? { comments: initiative.comments } : {}),
                     createdAt: initiative.createdAt,
                     updatedAt: initiative.updatedAt,
                     order: initiative.order,
@@ -309,7 +669,22 @@ export function applyPlanningSyncChanges(input) {
             }
         }
     }
-    if (incomingWorkstreams.size > 0) {
+    if (incomingWorkstreams.size > 0 && input.coexistenceDirection) {
+        if (!input.durabilityStore || !input.tenantId || !input.now) {
+            throw new Error('Workstream coexistence requires durability store, tenant, and timestamp.');
+        }
+        applyWorkstreamSyncChangesWithCoexistence({
+            store: input.durabilityStore,
+            core,
+            tenantId: input.tenantId,
+            workspaceId,
+            direction: input.coexistenceDirection,
+            incomingWorkstreams,
+            requiredCombinedProjectionOwner: input.coexistenceDirection === 'local-pull' ? 'v2' : undefined,
+            now: input.now,
+        });
+    }
+    else if (incomingWorkstreams.size > 0) {
         for (const workstream of incomingWorkstreams.values()) {
             try {
                 core.upsertWorkstreamForSync({
@@ -320,6 +695,7 @@ export function applyPlanningSyncChanges(input) {
                     title: workstream.title,
                     description: workstream.description,
                     ownerId: workstream.ownerId,
+                    ...(workstream.comments !== undefined ? { comments: workstream.comments } : {}),
                     createdAt: workstream.createdAt,
                     updatedAt: workstream.updatedAt,
                     order: workstream.order,
@@ -337,39 +713,130 @@ export function applyPlanningSyncChanges(input) {
             }
         }
     }
-    if (incomingTaxonomyState || Array.isArray(incomingTaxonomies)) {
-        const nextTaxonomyState = incomingTaxonomyState || { taxonomies: incomingTaxonomies || [] };
-        if (!incomingTaxonomiesUpdatedAt) {
-            if (typeof core.updateTaxonomyState === 'function') {
-                core.updateTaxonomyState(nextTaxonomyState, workspaceId);
-            }
-            else {
-                core.updateTaxonomies(Array.isArray(incomingTaxonomies) ? incomingTaxonomies : []);
-            }
+    for (const identity of input.incomingIdentities?.values() || []) {
+        const applied = core.applyPlanningEntityIdentityForSync(identity, workspaceId);
+        if (!applied) {
+            throw new Error(`Planning identity parent is missing: ${identity.entityType}:${identity.entityId}`);
+        }
+    }
+}
+export function applyTaxonomySyncChanges(input) {
+    const hasTaxonomy = Boolean(input.incomingTaxonomyState) || Array.isArray(input.incomingTaxonomies);
+    if (!hasTaxonomy)
+        return { applied: false, protected: false };
+    const nextTaxonomyState = input.incomingTaxonomyState
+        || { taxonomies: (input.incomingTaxonomies || []) };
+    let pendingTaxonomyMeta = null;
+    let notifyLegacyCommit = false;
+    const applyLegacy = (boundaryHeld = false) => {
+        const applyState = () => boundaryHeld
+            ? input.core.replaceTaxonomyStateForLegacySync(nextTaxonomyState, input.workspaceId)
+            : input.core.updateTaxonomyState(nextTaxonomyState, input.workspaceId);
+        if (!input.incomingTaxonomiesUpdatedAt) {
+            applyState();
+            if (boundaryHeld)
+                notifyLegacyCommit = true;
             const fallbackHash = createHash('sha256').update(JSON.stringify(nextTaxonomyState)).digest('hex');
-            workspaceTaxonomySyncMeta.set(workspaceId, {
-                updatedAt: new Date().toISOString(),
-                hash: fallbackHash
-            });
+            pendingTaxonomyMeta = { updatedAt: new Date().toISOString(), hash: fallbackHash };
+            return true;
         }
-        else {
-            const incomingTaxonomyHash = createHash('sha256').update(JSON.stringify(nextTaxonomyState)).digest('hex');
-            const currentMeta = workspaceTaxonomySyncMeta.get(workspaceId) || { updatedAt: '', hash: '' };
-            const compare = resolveSyncConflictOrdering(incomingTaxonomiesUpdatedAt, currentMeta.updatedAt, incomingTaxonomyHash, currentMeta.hash);
-            if (compare >= 0) {
-                if (typeof core.updateTaxonomyState === 'function') {
-                    core.updateTaxonomyState(nextTaxonomyState, workspaceId);
-                }
-                else {
-                    core.updateTaxonomies(Array.isArray(incomingTaxonomies) ? incomingTaxonomies : []);
+        const incomingHash = createHash('sha256').update(JSON.stringify(nextTaxonomyState)).digest('hex');
+        const currentMeta = input.workspaceTaxonomySyncMeta.get(input.workspaceId) || { updatedAt: '', hash: '' };
+        const compare = resolveSyncConflictOrdering(input.incomingTaxonomiesUpdatedAt, currentMeta.updatedAt, incomingHash, currentMeta.hash);
+        if (compare < 0)
+            return false;
+        applyState();
+        if (boundaryHeld)
+            notifyLegacyCommit = true;
+        pendingTaxonomyMeta = { updatedAt: input.incomingTaxonomiesUpdatedAt, hash: incomingHash };
+        return true;
+    };
+    if (!input.coexistenceDirection) {
+        const result = { applied: applyLegacy(), protected: false };
+        if (pendingTaxonomyMeta)
+            input.workspaceTaxonomySyncMeta.set(input.workspaceId, pendingTaxonomyMeta);
+        return result;
+    }
+    const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+    let notifyDurableCommit = false;
+    const result = runTaxonomyCoexistenceTransaction({
+        store,
+        tenantId: input.core.getTenantId(),
+        workspaceId: input.workspaceId,
+        direction: input.coexistenceDirection,
+        now: input.incomingTaxonomiesUpdatedAt || new Date().toISOString(),
+        apply: (ownership) => {
+            if (input.coexistenceDirection === 'cloud-push') {
+                if (ownership.owned || ownership.activeOperation || input.assertedActiveV3Taxonomy === true) {
+                    return { applied: false, protected: true };
                 }
-                workspaceTaxonomySyncMeta.set(workspaceId, {
-                    updatedAt: incomingTaxonomiesUpdatedAt,
-                    hash: incomingTaxonomyHash
-                });
+                return { applied: applyLegacy(true), protected: false };
+            }
+            if (ownership.activeOperation)
+                return { applied: false, protected: true };
+            const marker = input.incomingDurableRevision;
+            if (!marker) {
+                if (ownership.owned)
+                    return { applied: false, protected: true };
+                return { applied: applyLegacy(true), protected: false };
+            }
+            if (!input.incomingTaxonomyState) {
+                throw new Error('A durable taxonomy revision requires a complete taxonomy state.');
+            }
+            const canonicalState = serializeTaxonomyStateForSync(input.incomingTaxonomyState);
+            const canonicalFingerprint = fingerprintWorkspaceSyncPayload(canonicalState);
+            if (canonicalFingerprint !== marker.canonicalFingerprint) {
+                throw new Error('Taxonomy durable revision fingerprint does not match the payload.');
             }
+            const replicated = store.applyReplicatedEntityRevision({
+                tenantId: input.core.getTenantId(),
+                workspaceId: input.workspaceId,
+                domain: marker.domain,
+                entityId: marker.entityId,
+                sequence: marker.sequence,
+                entityRevision: marker.entityRevision,
+                lifecycleRevision: marker.lifecycleRevision,
+                canonicalFingerprint,
+                now: input.incomingTaxonomiesUpdatedAt,
+                applyMutation: () => input.core.replaceTaxonomyStateForDurableSync({
+                    workspaceId: input.workspaceId,
+                    taxonomyState: canonicalState,
+                    updatedAt: input.incomingTaxonomiesUpdatedAt,
+                }),
+            });
+            if (replicated.state === 'applied') {
+                notifyDurableCommit = true;
+            }
+            if (replicated.state === 'deferred') {
+                throw new Error('Taxonomy replication cannot defer its installed revision.');
+            }
+            return {
+                applied: replicated.state === 'applied',
+                protected: replicated.state !== 'applied',
+                revisionState: replicated.state,
+            };
+        },
+    });
+    if (notifyDurableCommit) {
+        input.workspaceTaxonomySyncMeta.set(input.workspaceId, {
+            updatedAt: input.incomingTaxonomiesUpdatedAt,
+            hash: input.incomingDurableRevision.canonicalFingerprint,
+        });
+        try {
+            input.core.notifyDurableTaxonomyCommitted(input.workspaceId);
         }
+        catch { /* committed taxonomy state remains authoritative */ }
     }
+    else if (pendingTaxonomyMeta) {
+        input.workspaceTaxonomySyncMeta.set(input.workspaceId, pendingTaxonomyMeta);
+    }
+    if (notifyLegacyCommit) {
+        try {
+            input.core.notifyTaxonomyStateForLegacySync(input.workspaceId);
+        }
+        catch { /* committed taxonomy state remains authoritative */ }
+    }
+    return result;
 }
 export function applyAiProfileAndMemberSyncChanges(input) {
     const { core, workspaceId, incomingAiProfiles, workspaceMembers, recordSyncDiagnostic, assertSyncedAiProfilesPersisted, createSyncRouteError, } = input;
@@ -384,6 +851,8 @@ export function applyAiProfileAndMemberSyncChanges(input) {
                     username: profile.username,
                     icon: profile.icon,
                     color: profile.color,
+                    colorSource: parseAiProfileColorSource(profile.colorSource),
+                    colorUpdatedAt: profile.colorUpdatedAt ?? null,
                     ...(Object.prototype.hasOwnProperty.call(profile, 'avatarUrl') ? { avatarUrl: profile.avatarUrl ?? null } : {}),
                     ...(Object.prototype.hasOwnProperty.call(profile, 'avatarSourceUrl') ? { avatarSourceUrl: profile.avatarSourceUrl ?? null } : {}),
                     ...(Object.prototype.hasOwnProperty.call(profile, 'avatarRevision') ? { avatarRevision: profile.avatarRevision ?? 0 } : {}),
@@ -441,7 +910,7 @@ export function applyAiProfileAndMemberSyncChanges(input) {
     }
 }
 export async function applyContentSyncChanges(input) {
-    const { core, workspaceId, incomingDocuments, incomingDocumentDeletes, incomingAssets, incomingAssetDeletes, basePath, hasObjectStorageClient, hasDocumentSyncMetadataDrift, hasBinaryAssetSyncMetadataDrift, getExistingDocument, writeWorkspaceSyncDocument, deleteWorkspaceSyncDocument, writeWorkspaceSyncBinaryAsset, deleteWorkspaceSyncBinaryAsset, getExistingBinaryAsset, recordSyncDiagnostic, options, } = input;
+    const { core, workspaceId, incomingDocuments, incomingDocumentDeletes, incomingAssets, incomingAssetDeletes, basePath, hasObjectStorageClient, hasDocumentSyncMetadataDrift, hasBinaryAssetSyncMetadataDrift, getExistingDocument, writeWorkspaceSyncDocument, deleteWorkspaceSyncDocument, writeWorkspaceSyncBinaryAsset, deleteWorkspaceSyncBinaryAsset, getExistingBinaryAsset, recordSyncDiagnostic, options, phase = 'all', } = input;
     const contentApplyFailures = [];
     const recordContentApplyFailure = (failure) => {
         contentApplyFailures.push(failure);
@@ -456,7 +925,7 @@ export async function applyContentSyncChanges(input) {
         error.details = { failures: contentApplyFailures.slice(0, 10) };
         throw error;
     };
-    if (incomingDocuments.length > 0) {
+    if (phase !== 'deletes' && incomingDocuments.length > 0) {
         for (const doc of incomingDocuments) {
             try {
                 const existingDoc = core.getDocumentWatermark(workspaceId, doc.path);
@@ -474,7 +943,11 @@ export async function applyContentSyncChanges(input) {
                     }
                 }
                 const compare = resolveSyncConflictOrdering(doc.updatedAt, existingUpdatedAt, incomingHash, existingHash);
-                if (compare < 0)
+                const replacesExternalPlaceholder = metadataDrift
+                    && existingDocFallback?.storageProvider === 'external'
+                    && Boolean(doc.assetId && doc.assetId !== existingDocFallback.assetId)
+                    && Date.parse(doc.updatedAt) === Date.parse(existingUpdatedAt);
+                if (compare < 0 && !replacesExternalPlaceholder)
                     continue;
                 if (compare === 0 && existingHash === incomingHash && !metadataDrift && !hasObjectStorageClient())
                     continue;
@@ -500,7 +973,7 @@ export async function applyContentSyncChanges(input) {
             }
         }
     }
-    if (incomingDocumentDeletes.size > 0) {
+    if (phase !== 'upserts' && incomingDocumentDeletes.size > 0) {
         for (const [docPath, deletedAt] of incomingDocumentDeletes.entries()) {
             const existingDoc = core.getDocumentWatermark(workspaceId, docPath);
             const existingUpdatedAt = String(existingDoc?.updatedAt || '').trim();
@@ -511,7 +984,7 @@ export async function applyContentSyncChanges(input) {
             deleteWorkspaceSyncDocument(basePath, docPath, workspaceId);
         }
     }
-    if (incomingAssets.length > 0) {
+    if (phase !== 'deletes' && incomingAssets.length > 0) {
         for (const asset of incomingAssets) {
             try {
                 const localAssetPath = path.resolve(basePath, asset.path);
@@ -554,7 +1027,7 @@ export async function applyContentSyncChanges(input) {
         }
     }
     throwIfContentApplyFailed();
-    if (incomingAssetDeletes.size > 0) {
+    if (phase !== 'upserts' && incomingAssetDeletes.size > 0) {
         for (const [assetPath, deletedAt] of incomingAssetDeletes.entries()) {
             const existing = getExistingBinaryAsset(assetPath, workspaceId);
             const existingUpdatedAt = String(existing?.updatedAt || '').trim();
@@ -579,7 +1052,7 @@ export async function applyContentSyncChanges(input) {
     }
 }
 export function applyCollaborationSyncChanges(input) {
-    const { core, workspaceId, incomingDocumentReviewSessions, incomingDocumentReviewSessionDeletes, incomingDocumentReviewComments, incomingDocumentReviewCommentDeletes, incomingAnnotatedAttachmentSessions, incomingAnnotatedAttachmentSessionDeletes, recordSyncDiagnostic, createSyncRouteError, } = input;
+    const { core, workspaceId, incomingDocumentReviewSessions, incomingDocumentReviewSessionDeletes, incomingDocumentReviewComments, incomingDocumentReviewCommentDeletes, incomingAnnotatedAttachmentSessions, incomingAnnotatedAttachmentSessionDeletes, incomingTaskforceAgents = new Map(), incomingAgentRoles = new Map(), incomingTaskforceAgentSkills = new Map(), incomingAgentConversations = new Map(), recordSyncDiagnostic, createSyncRouteError, } = input;
     if (incomingDocumentReviewSessions.size > 0) {
         for (const session of incomingDocumentReviewSessions.values()) {
             try {
@@ -625,7 +1098,9 @@ export function applyCollaborationSyncChanges(input) {
         }
     }
     if (incomingDocumentReviewComments.size > 0) {
-        for (const comment of incomingDocumentReviewComments.values()) {
+        const orderedDocumentReviewComments = Array.from(incomingDocumentReviewComments.values())
+            .sort((left, right) => Number(Boolean(left.parentCommentId)) - Number(Boolean(right.parentCommentId)));
+        for (const comment of orderedDocumentReviewComments) {
             try {
                 const existingComments = core.listDocumentReviewCommentsForSync({
                     workspaceId,
@@ -633,29 +1108,84 @@ export function applyCollaborationSyncChanges(input) {
                 });
                 const existing = existingComments.find((entry) => entry.id === comment.id) || null;
                 const incomingTieBreak = createHash('sha256')
-                    .update(JSON.stringify({ body: comment.body, anchor: comment.anchor, deletedAt: comment.deletedAt }))
+                    .update(JSON.stringify({
+                    body: comment.body,
+                    anchor: comment.anchor,
+                    deletedAt: comment.deletedAt,
+                    parentCommentId: comment.parentCommentId,
+                    authorActorId: comment.authorActorId,
+                    updatedByActorId: comment.updatedByActorId,
+                    deletedByActorId: comment.deletedByActorId,
+                }))
                     .digest('hex');
                 const existingTieBreak = existing
                     ? createHash('sha256')
-                        .update(JSON.stringify({ body: existing.body, anchor: existing.anchor, deletedAt: existing.deletedAt }))
+                        .update(JSON.stringify({
+                        body: existing.body,
+                        anchor: existing.anchor,
+                        deletedAt: existing.deletedAt,
+                        parentCommentId: existing.parentCommentId,
+                        authorActorId: existing.authorActorId,
+                        updatedByActorId: existing.updatedByActorId,
+                        deletedByActorId: existing.deletedByActorId,
+                    }))
                         .digest('hex')
                     : '';
-                const compare = resolveSyncConflictOrdering(comment.updatedAt, String(existing?.updatedAt || '').trim(), incomingTieBreak, existingTieBreak);
-                if (compare < 0)
+                const metadataCompare = resolveSyncConflictOrdering(comment.updatedAt, String(existing?.updatedAt || '').trim(), incomingTieBreak, existingTieBreak);
+                const incomingLifecycleTieBreak = createHash('sha256')
+                    .update(JSON.stringify({
+                    threadStatus: comment.threadStatus,
+                    resolvedAt: comment.resolvedAt,
+                    resolvedByActorId: comment.resolvedByActorId,
+                }))
+                    .digest('hex');
+                const existingLifecycleTieBreak = existing
+                    ? createHash('sha256')
+                        .update(JSON.stringify({
+                        threadStatus: existing.threadStatus,
+                        resolvedAt: existing.resolvedAt,
+                        resolvedByActorId: existing.resolvedByActorId,
+                    }))
+                        .digest('hex')
+                    : '';
+                const lifecycleCompare = comment.threadStatusUpdatedAt === undefined
+                    ? -1
+                    : resolveSyncConflictOrdering(String(comment.threadStatusUpdatedAt || '').trim(), String(existing?.threadStatusUpdatedAt || '').trim(), incomingLifecycleTieBreak, existingLifecycleTieBreak);
+                if (metadataCompare < 0 && lifecycleCompare < 0)
                     continue;
                 core.upsertDocumentReviewCommentForSync({
                     id: comment.id,
                     tenantId: core.getTenantId(),
                     workspaceId,
-                    sessionId: comment.sessionId,
-                    body: comment.body,
-                    anchor: comment.anchor,
-                    order: comment.order,
-                    authorActorId: comment.authorActorId,
-                    createdAt: comment.createdAt,
-                    updatedAt: comment.updatedAt,
-                    deletedAt: comment.deletedAt,
+                    sessionId: metadataCompare >= 0 ? comment.sessionId : existing.sessionId,
+                    body: metadataCompare >= 0 ? comment.body : existing.body,
+                    anchor: (metadataCompare >= 0 ? comment.anchor : existing.anchor),
+                    order: metadataCompare >= 0 ? comment.order : existing.order,
+                    authorActorId: metadataCompare >= 0 ? comment.authorActorId : existing.authorActorId,
+                    updatedByActorId: metadataCompare >= 0 ? comment.updatedByActorId : existing.updatedByActorId,
+                    deletedByActorId: metadataCompare >= 0 ? comment.deletedByActorId : existing.deletedByActorId,
+                    parentCommentId: metadataCompare >= 0 ? comment.parentCommentId : existing.parentCommentId,
+                    threadStatus: lifecycleCompare >= 0 ? comment.threadStatus : undefined,
+                    threadStatusUpdatedAt: lifecycleCompare >= 0 ? comment.threadStatusUpdatedAt : undefined,
+                    resolvedAt: lifecycleCompare >= 0 ? comment.resolvedAt : undefined,
+                    resolvedByActorId: lifecycleCompare >= 0 ? comment.resolvedByActorId : undefined,
+                    createdAt: metadataCompare >= 0 ? comment.createdAt : existing.createdAt,
+                    updatedAt: metadataCompare >= 0 ? comment.updatedAt : existing.updatedAt,
+                    deletedAt: metadataCompare >= 0 ? comment.deletedAt : existing.deletedAt,
                 });
+                if (comment.parentCommentId) {
+                    const rootExists = core.listDocumentReviewCommentsForSync({
+                        workspaceId,
+                        includeDeleted: true,
+                    }).some((entry) => entry.id === comment.parentCommentId && !entry.deletedAt && !entry.parentCommentId);
+                    if (!rootExists) {
+                        recordSyncDiagnostic(workspaceId, 'apply', 'Retained document review reply awaiting its root comment.', {
+                            source: 'apply.documentReviewCommentOrphan',
+                            commentId: comment.id,
+                            parentCommentId: comment.parentCommentId,
+                        });
+                    }
+                }
             }
             catch (error) {
                 recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert document review comment during sync apply.', {
@@ -693,7 +1223,8 @@ export function applyCollaborationSyncChanges(input) {
         }
     }
     if (incomingDocumentReviewCommentDeletes.size > 0) {
-        for (const [commentId, deletedAt] of incomingDocumentReviewCommentDeletes.entries()) {
+        for (const [commentId, deletion] of incomingDocumentReviewCommentDeletes.entries()) {
+            const { deletedAt, deletedByActorId } = deletion;
             try {
                 const existing = core.listDocumentReviewCommentsForSync({
                     workspaceId,
@@ -702,7 +1233,12 @@ export function applyCollaborationSyncChanges(input) {
                 const compare = resolveSyncConflictOrdering(deletedAt, String(existing?.updatedAt || '').trim(), `delete:${commentId}`, String(existing?.id || '').trim());
                 if (existing && compare < 0)
                     continue;
-                core.deleteDocumentReviewCommentForSync({ workspaceId, commentId, deletedAt });
+                core.deleteDocumentReviewCommentForSync({
+                    workspaceId,
+                    commentId,
+                    deletedAt,
+                    deletedByActorId,
+                });
             }
             catch (error) {
                 recordSyncDiagnostic(workspaceId, 'apply', 'Failed to delete document review comment during sync apply.', {
@@ -782,6 +1318,232 @@ export function applyCollaborationSyncChanges(input) {
             }
         }
     }
+    if (incomingTaskforceAgents.size > 0) {
+        const agentStore = new TaskforceAgentStore(core.getDatabaseAdapter(), core.getTenantId());
+        for (const agent of incomingTaskforceAgents.values()) {
+            try {
+                const existing = agentStore.getForSync(workspaceId, agent.id);
+                const incomingTieBreak = createHash('sha256')
+                    .update(JSON.stringify({
+                    definition: agent.definition,
+                    definitionRevision: agent.definitionRevision,
+                    definitionHash: agent.definitionHash,
+                    lifecycleStatus: agent.lifecycleStatus,
+                    managedProfileId: agent.managedProfileId,
+                    name: agent.name,
+                    modelProvider: agent.modelProvider,
+                    providerKey: agent.providerKey,
+                    modelKey: agent.modelKey,
+                    modelTier: agent.modelTier,
+                    systemPrompt: agent.systemPrompt,
+                    enabled: agent.enabled,
+                    deletedAt: agent.deletedAt ?? null,
+                }))
+                    .digest('hex');
+                const existingTieBreak = existing
+                    ? createHash('sha256')
+                        .update(JSON.stringify({
+                        definition: existing.definitionValue,
+                        definitionRevision: existing.definitionRevision,
+                        definitionHash: existing.definitionHash,
+                        lifecycleStatus: existing.lifecycleStatus,
+                        managedProfileId: existing.managedProfileId,
+                        name: existing.name,
+                        modelProvider: existing.modelProvider,
+                        providerKey: existing.providerKey,
+                        modelKey: existing.modelKey,
+                        modelTier: existing.modelTier,
+                        systemPrompt: existing.systemPrompt,
+                        enabled: existing.enabled,
+                        deletedAt: existing.deletedAt ?? null,
+                    }))
+                        .digest('hex')
+                    : '';
+                const compare = resolveSyncConflictOrdering(agent.deletedAt || agent.updatedAt, String(existing?.deletedAt || existing?.updatedAt || '').trim(), incomingTieBreak, existingTieBreak);
+                if (compare < 0)
+                    continue;
+                agentStore.upsertForSync({
+                    id: agent.id,
+                    workspaceId,
+                    ...(Object.prototype.hasOwnProperty.call(agent, 'definition') ? {
+                        definition: agent.definition,
+                        definitionRevision: agent.definitionRevision,
+                        definitionHash: agent.definitionHash,
+                        lifecycleStatus: agent.lifecycleStatus,
+                        managedProfileId: agent.managedProfileId,
+                    } : {}),
+                    name: agent.name,
+                    modelProvider: agent.modelProvider,
+                    providerKey: agent.providerKey,
+                    modelKey: agent.modelKey,
+                    modelTier: agent.modelTier,
+                    systemPrompt: agent.systemPrompt,
+                    enabled: agent.enabled,
+                    createdByUserId: agent.createdByUserId,
+                    updatedByUserId: agent.updatedByUserId,
+                    createdAt: agent.createdAt,
+                    updatedAt: agent.updatedAt,
+                    deletedAt: agent.deletedAt,
+                });
+            }
+            catch (error) {
+                const syncError = error;
+                const rejectionCode = String(syncError?.code || '').trim();
+                const rejectedCanonicalPayload = (rejectionCode === 'TASKFORCE_AGENT_SYNC_HASH_MISMATCH'
+                    || rejectionCode === 'TASKFORCE_AGENT_SYNC_INVALID_ENVELOPE'
+                    || rejectionCode === 'TASKFORCE_AGENT_SYNC_INVALID_DEFINITION'
+                    || rejectionCode === 'TASKFORCE_AGENT_SYNC_LEGACY_PROJECTION_REJECTED');
+                const details = {
+                    source: 'apply.taskforceAgentUpsert',
+                    agentId: agent.id,
+                    error: String(error?.message || error || ''),
+                    errorCode: String(error?.code || '').trim() || null
+                };
+                recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert Taskforce Agent during sync apply.', details);
+                throw createSyncRouteError(`Failed to persist Taskforce Agent ${agent.id} during sync apply: ${String(error?.message || error || 'Unknown error')}`, details, {
+                    code: rejectedCanonicalPayload ? rejectionCode : 'TASKFORCE_AGENT_SYNC_APPLY_FAILED',
+                    statusCode: rejectedCanonicalPayload ? 409 : 500,
+                });
+            }
+        }
+    }
+    if (incomingAgentRoles.size > 0) {
+        const roleStore = new AgentRoleStore(core.getDatabaseAdapter(), core.getTenantId());
+        for (const role of incomingAgentRoles.values()) {
+            try {
+                const existing = roleStore.get(workspaceId, role.id, { includeDeleted: true });
+                const incomingTieBreak = createHash('sha256')
+                    .update(JSON.stringify({
+                    lifecycleStatus: role.lifecycleStatus,
+                    currentRevision: role.currentRevision,
+                    currentContentHash: role.currentContentHash,
+                    revisions: role.revisions,
+                    deletedAt: role.deletedAt,
+                }))
+                    .digest('hex');
+                const existingSnapshot = existing
+                    ? roleStore.listForSync(workspaceId).find((entry) => entry.id === role.id)
+                    : null;
+                const existingTieBreak = existingSnapshot
+                    ? createHash('sha256')
+                        .update(JSON.stringify({
+                        lifecycleStatus: existingSnapshot.lifecycleStatus,
+                        currentRevision: existingSnapshot.currentRevision,
+                        currentContentHash: existingSnapshot.currentContentHash,
+                        revisions: existingSnapshot.revisions,
+                        deletedAt: existingSnapshot.deletedAt,
+                    }))
+                        .digest('hex')
+                    : '';
+                const compare = resolveSyncConflictOrdering(role.deletedAt || role.updatedAt, String(existing?.deletedAt || existing?.updatedAt || '').trim(), incomingTieBreak, existingTieBreak);
+                if (compare < 0)
+                    continue;
+                roleStore.upsertForSync(role);
+            }
+            catch (error) {
+                const domainCode = String(error?.code || '').trim();
+                const details = {
+                    source: 'apply.agentRoleUpsert',
+                    roleId: role.id,
+                    error: String(error?.message || error || ''),
+                    errorCode: domainCode || null,
+                };
+                recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert Agent Role during sync apply.', details);
+                throw createSyncRouteError(`Failed to persist Agent Role ${role.id} during sync apply: ${String(error?.message || error || 'Unknown error')}`, details, { code: domainCode || 'AGENT_ROLE_SYNC_APPLY_FAILED', statusCode: 409 });
+            }
+        }
+    }
+    if (incomingTaskforceAgentSkills.size > 0) {
+        const skillStore = new TaskforceAgentSkillStore(core.getDatabaseAdapter(), core.getTenantId());
+        for (const skill of incomingTaskforceAgentSkills.values()) {
+            try {
+                skillStore.upsertForSync(skill);
+            }
+            catch (error) {
+                const syncError = error;
+                const rejectionCode = String(syncError?.code || '').trim();
+                const rejectedCanonicalPayload = rejectionCode.startsWith('TASKFORCE_AGENT_SKILL_SYNC_');
+                const details = {
+                    source: 'apply.taskforceAgentSkillUpsert',
+                    skillId: skill.id,
+                    error: String(error?.message || error || ''),
+                    errorCode: rejectionCode || null
+                };
+                recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert Taskforce Agent Skill during sync apply.', details);
+                throw createSyncRouteError(`Failed to persist Taskforce Agent Skill ${skill.id} during sync apply: ${String(error?.message || error || 'Unknown error')}`, details, {
+                    code: rejectedCanonicalPayload ? rejectionCode : 'TASKFORCE_AGENT_SKILL_SYNC_APPLY_FAILED',
+                    statusCode: rejectedCanonicalPayload ? 409 : 500,
+                });
+            }
+        }
+    }
+    if (incomingAgentConversations.size > 0) {
+        const conversationStore = new TaskforceAgentConversationStore(core.getDatabaseAdapter(), core.getTenantId());
+        for (const conversation of incomingAgentConversations.values()) {
+            try {
+                const existing = conversationStore.getByIdForSync(workspaceId, conversation.id);
+                const incomingTieBreak = createHash('sha256')
+                    .update(JSON.stringify({
+                    agentId: conversation.agentId,
+                    taskId: conversation.taskId,
+                    title: conversation.title,
+                    messages: conversation.messages,
+                    modelProvider: conversation.modelProvider,
+                    modelId: conversation.modelId,
+                    usage: conversation.usage,
+                    latencyMs: conversation.latencyMs,
+                    deletedAt: conversation.deletedAt ?? null,
+                }))
+                    .digest('hex');
+                const existingTieBreak = existing
+                    ? createHash('sha256')
+                        .update(JSON.stringify({
+                        agentId: existing.agentId,
+                        taskId: existing.taskId,
+                        title: existing.title,
+                        messages: existing.messages,
+                        modelProvider: existing.modelProvider,
+                        modelId: existing.modelId,
+                        usage: existing.usage,
+                        latencyMs: existing.latencyMs,
+                        deletedAt: existing.deletedAt ?? null,
+                    }))
+                        .digest('hex')
+                    : '';
+                const compare = resolveSyncConflictOrdering(conversation.deletedAt || conversation.updatedAt, String(existing?.deletedAt || existing?.updatedAt || '').trim(), incomingTieBreak, existingTieBreak);
+                if (compare < 0)
+                    continue;
+                conversationStore.upsertForSync({
+                    id: conversation.id,
+                    workspaceId,
+                    agentId: conversation.agentId,
+                    taskId: conversation.taskId,
+                    title: conversation.title,
+                    messages: conversation.messages,
+                    modelProvider: conversation.modelProvider,
+                    modelId: conversation.modelId,
+                    usage: conversation.usage,
+                    latencyMs: conversation.latencyMs,
+                    createdByUserId: conversation.createdByUserId,
+                    updatedByUserId: conversation.updatedByUserId,
+                    createdAt: conversation.createdAt,
+                    updatedAt: conversation.updatedAt,
+                    deletedAt: conversation.deletedAt,
+                });
+            }
+            catch (error) {
+                const details = {
+                    source: 'apply.agentConversationUpsert',
+                    conversationId: conversation.id,
+                    agentId: conversation.agentId,
+                    error: String(error?.message || error || ''),
+                    errorCode: String(error?.code || '').trim() || null
+                };
+                recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert Taskforce Agent conversation during sync apply.', details);
+                throw createSyncRouteError(`Failed to persist Taskforce Agent conversation ${conversation.id} during sync apply: ${String(error?.message || error || 'Unknown error')}`, details, { code: 'AGENT_CONVERSATION_SYNC_APPLY_FAILED', statusCode: 500 });
+            }
+        }
+    }
 }
 export function applyTaskActivitySyncChanges(input) {
     const { core, workspaceId, incomingTaskEvents, recordSyncDiagnostic, createSyncRouteError, } = input;
@@ -811,6 +1573,11 @@ export function applyTaskActivitySyncChanges(input) {
                 workspaceId,
                 eventId: event.id,
             });
+            // V3 installs the authoritative snapshot through its acknowledged
+            // transaction. A delayed legacy event with the same operation ID
+            // must not replace it based on client clock or payload tie-breaks.
+            if (existing && isTaskMetadataActivityEventId(event.id))
+                continue;
             const incomingTieBreak = createHash('sha256')
                 .update(JSON.stringify({
                 entityType,