@taskforcehq/taskforce 0.3.303 → 0.3.304

package/dist/sync/contentSyncState.js

@@ -80,8 +80,7 @@ export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc, options) {
             incomingReferenceNumber: normalizedIncomingReference
         });
     }
-    return referenceNumberMismatch
-        || (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
+    return (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
         || existingAsset.version !== normalizedIncomingVersion
         || (existingAsset.documentId || null) !== normalizedIncomingDocumentId
         || (existingAsset.logicalName || null) !== normalizedIncomingLogicalName
@@ -130,8 +129,7 @@ export function hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset, option
             incomingReferenceNumber: normalizedIncomingReference
         });
     }
-    return referenceNumberMismatch
-        || (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
+    return (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
         || (existingAsset.logicalName || null) !== normalizedIncomingLogicalName
         || (existingAsset.originalFilename || null) !== normalizedIncomingFilename
         || (primaryLink?.taskId || null) !== normalizedIncomingTaskId
@@ -733,8 +731,10 @@ export async function writeWorkspaceSyncDocument(deps, basePath, doc, workspaceI
             const incomingReferenceNumber = Number.isFinite(Number(doc.referenceNumber))
                 ? Math.max(1, Math.floor(Number(doc.referenceNumber)))
                 : null;
-            const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true
-                || Boolean(existing?.referenceNumber && incomingReferenceNumber && existing.referenceNumber !== incomingReferenceNumber);
+            const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true;
+            const nextReferenceNumber = allowReferenceNumberReassignment
+                ? (incomingReferenceNumber ?? existing?.referenceNumber ?? null)
+                : (existing?.referenceNumber ?? incomingReferenceNumber ?? null);
             const originalFilename = String(doc.originalFilename || existing?.originalFilename || path.basename(normalizedPath) || 'document.md').trim() || 'document.md';
             const asset = deps.workspaceAssetStore.upsertAsset({
                 assetId: String(doc.assetId || existing?.assetId || `asset-${randomUUID().replace(/-/g, '')}`),
@@ -750,7 +750,7 @@ export async function writeWorkspaceSyncDocument(deps, basePath, doc, workspaceI
                 contentSha256: contentHash,
                 sizeBytes: Buffer.byteLength(content, 'utf8'),
                 documentId: String(doc.documentId || existing?.documentId || `doc-${randomUUID().replace(/-/g, '')}`),
-                referenceNumber: incomingReferenceNumber ?? existing?.referenceNumber ?? null,
+                referenceNumber: nextReferenceNumber,
                 version: Number.isFinite(Number(doc.version))
                     ? Math.max(1, Math.floor(Number(doc.version)))
                     : Math.max(1, Number(existing?.version || 0) + 1),
@@ -826,8 +826,10 @@ export async function writeWorkspaceSyncBinaryAsset(deps, basePath, asset, works
         const incomingReferenceNumber = Number.isFinite(Number(asset.referenceNumber))
             ? Math.max(1, Math.floor(Number(asset.referenceNumber)))
             : null;
-        const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true
-            || Boolean(existing?.referenceNumber && incomingReferenceNumber && existing.referenceNumber !== incomingReferenceNumber);
+        const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true;
+        const nextReferenceNumber = allowReferenceNumberReassignment
+            ? (incomingReferenceNumber ?? existing?.referenceNumber ?? null)
+            : (existing?.referenceNumber ?? incomingReferenceNumber ?? null);
         const assetRecord = deps.workspaceAssetStore.upsertAsset({
             assetId: String(asset.assetId || existing?.assetId || `asset-${randomUUID().replace(/-/g, '')}`),
             workspaceId,
@@ -842,7 +844,7 @@ export async function writeWorkspaceSyncBinaryAsset(deps, basePath, asset, works
             contentSha256: createHash('sha256').update(buffer).digest('hex'),
             sizeBytes: buffer.length,
             documentId: null,
-            referenceNumber: incomingReferenceNumber ?? existing?.referenceNumber ?? null,
+            referenceNumber: nextReferenceNumber,
             version: null,
             isLatest: true,
             scanStatus: existing?.scanStatus || 'clean',

package/dist/sync/syncApplyHandlers.d.ts

@@ -1,6 +1,7 @@
 import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
-import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
+import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncChange, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncTaskEventSnapshot, WorkspaceSyncTaskSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
 import type { BinaryAssetSyncPayload, DocumentSyncPayload } from './contentSyncPayload.js';
+import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
 type SyncCore = TaskforceCore & TaskforceSyncCapable;
 type SyncRouteError = Error & {
     code?: string;
@@ -12,7 +13,81 @@ type CreateSyncRouteError = (message: string, details: Record<string, unknown>,
     code?: string;
     statusCode?: number;
 }) => SyncRouteError;
+type NormalizeIncomingAiProfileSurfaceType = (value: unknown, context: {
+    source: string;
+    profileId?: string;
+    workspaceId?: string;
+}) => AiProfileSurfaceType | null;
+type NormalizeTaskEventSyncPayload = (raw: unknown, workspaceId: string, sourceWatermark?: string) => WorkspaceSyncTaskEventSnapshot | null;
+export interface WorkspaceSyncIncomingTaskMutation {
+    archived: boolean;
+    task: WorkspaceSyncTaskSnapshot;
+}
+export interface WorkspaceSyncIncomingTaskApplyModel {
+    upserts: WorkspaceSyncIncomingTaskMutation[];
+    deletes: Map<string, string>;
+}
+export interface WorkspaceSyncIncomingApplyModel {
+    taskMutations: WorkspaceSyncIncomingTaskApplyModel;
+    planning: {
+        incomingTaxonomies: unknown[] | null;
+        incomingTaxonomyState: Record<string, unknown> | null;
+        incomingTaxonomiesUpdatedAt: string;
+        incomingInitiatives: Map<string, WorkspaceSyncInitiativeSnapshot>;
+        incomingWorkstreams: Map<string, WorkspaceSyncWorkstreamSnapshot>;
+    };
+    profiles: {
+        incomingAiProfiles: Map<string, WorkspaceSyncAiProfileSnapshot>;
+    };
+    content: {
+        incomingDocuments: DocumentSyncPayload[];
+        incomingDocumentDeletes: Map<string, string>;
+        incomingAssets: BinaryAssetSyncPayload[];
+        incomingAssetDeletes: Map<string, string>;
+    };
+    collaboration: {
+        incomingDocumentReviewSessions: Map<string, WorkspaceSyncDocumentReviewSessionSnapshot>;
+        incomingDocumentReviewSessionDeletes: Map<string, string>;
+        incomingDocumentReviewComments: Map<string, WorkspaceSyncDocumentReviewCommentSnapshot>;
+        incomingDocumentReviewCommentDeletes: Map<string, string>;
+        incomingAnnotatedAttachmentSessions: Map<string, WorkspaceSyncAnnotatedAttachmentSessionSnapshot>;
+        incomingAnnotatedAttachmentSessionDeletes: Map<string, string>;
+    };
+    taskActivity: {
+        incomingTaskEvents: Map<string, WorkspaceSyncTaskEventSnapshot>;
+    };
+}
+export interface PreparedWorkspaceTaskSyncSnapshot {
+    tasks: WorkspaceSyncTaskSnapshot[];
+    archived: WorkspaceSyncTaskSnapshot[];
+}
 export declare function resolveSyncConflictOrdering(incomingWatermark: string, existingWatermark: string, incomingTieBreak: string, existingTieBreak: string): number;
+export declare function classifyWorkspaceSyncChanges(input: {
+    workspaceId: string;
+    incomingChanges: WorkspaceSyncChange[];
+    normalizeWorkspaceSyncDocumentPath: (rawPath: unknown) => string | null;
+    normalizeTaskAssetPath: (rawPath: unknown) => string | null;
+    normalizeIncomingAiProfileSurfaceType: NormalizeIncomingAiProfileSurfaceType;
+    normalizeTaskEventSyncPayload: NormalizeTaskEventSyncPayload;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+}): WorkspaceSyncIncomingApplyModel;
+export declare function prepareTaskSyncSnapshotApply(input: {
+    core: SyncCore;
+    workspaceId: string;
+    taskMutations: WorkspaceSyncIncomingTaskApplyModel;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+}): PreparedWorkspaceTaskSyncSnapshot;
+export declare function applyTaskSyncDeletes(input: {
+    core: SyncCore;
+    workspaceId: string;
+    taskMutations: WorkspaceSyncIncomingTaskApplyModel;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+}): number;
+export declare function applyPreparedTaskSyncSnapshot(input: {
+    core: SyncCore;
+    workspaceId: string;
+    prepared: PreparedWorkspaceTaskSyncSnapshot;
+}): ReturnType<SyncCore['applyWorkspaceSyncSnapshot']>;
 export declare function applyPlanningSyncChanges(input: {
     core: SyncCore;
     workspaceId: string;
@@ -51,6 +126,10 @@ export declare function applyContentSyncChanges(input: {
     hasBinaryAssetSyncMetadataDrift: (workspaceId: string, asset: BinaryAssetSyncPayload, options?: {
         allowReferenceNumberReassignment?: boolean;
     }) => boolean;
+    getExistingDocument?: (docPath: string, workspaceId: string) => {
+        updatedAt?: string | null;
+        contentHash?: string | null;
+    } | null;
     writeWorkspaceSyncDocument: (basePath: string, doc: DocumentSyncPayload, workspaceId?: string, options?: {
         allowReferenceNumberReassignment?: boolean;
     }) => Promise<void>;
@@ -80,4 +159,11 @@ export declare function applyCollaborationSyncChanges(input: {
     recordSyncDiagnostic: RecordSyncDiagnostic;
     createSyncRouteError: CreateSyncRouteError;
 }): void;
+export declare function applyTaskActivitySyncChanges(input: {
+    core: SyncCore;
+    workspaceId: string;
+    incomingTaskEvents: Map<string, WorkspaceSyncTaskEventSnapshot>;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+    createSyncRouteError: CreateSyncRouteError;
+}): void;
 export {};

package/dist/sync/syncApplyHandlers.js

@@ -1,10 +1,285 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createHash } from 'crypto';
-import { compareWorkspaceMutationOrdering } from './workspaceSyncSurface.js';
+import { normalizeBinaryAssetDeleteSyncPayload, normalizeBinaryAssetSyncPayload, normalizeDocumentDeleteSyncPayload, normalizeDocumentSyncPayload, } from './contentSyncPayload.js';
+import { normalizeAiProfileSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDeleteSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, } from './collaborationSyncPayload.js';
+import { normalizeInitiativeSyncPayload, normalizeTaxonomySyncPayload, normalizeWorkstreamSyncPayload, } from './planningSyncPayload.js';
+import { normalizeTaskSyncPayload, taskSyncPayloadToCoreTask, } from './taskSyncPayload.js';
+import { compareWorkspaceMutationOrdering, getTaskMutationTieBreak, getTaskMutationWatermark } from './workspaceSyncSurface.js';
+function createIncomingApplyModel() {
+    return {
+        taskMutations: {
+            upserts: [],
+            deletes: new Map(),
+        },
+        planning: {
+            incomingTaxonomies: null,
+            incomingTaxonomyState: null,
+            incomingTaxonomiesUpdatedAt: '',
+            incomingInitiatives: new Map(),
+            incomingWorkstreams: new Map(),
+        },
+        profiles: {
+            incomingAiProfiles: new Map(),
+        },
+        content: {
+            incomingDocuments: [],
+            incomingDocumentDeletes: new Map(),
+            incomingAssets: [],
+            incomingAssetDeletes: new Map(),
+        },
+        collaboration: {
+            incomingDocumentReviewSessions: new Map(),
+            incomingDocumentReviewSessionDeletes: new Map(),
+            incomingDocumentReviewComments: new Map(),
+            incomingDocumentReviewCommentDeletes: new Map(),
+            incomingAnnotatedAttachmentSessions: new Map(),
+            incomingAnnotatedAttachmentSessionDeletes: new Map(),
+        },
+        taskActivity: {
+            incomingTaskEvents: new Map(),
+        },
+    };
+}
 export function resolveSyncConflictOrdering(incomingWatermark, existingWatermark, incomingTieBreak, existingTieBreak) {
     return compareWorkspaceMutationOrdering(String(incomingWatermark || '').trim(), String(existingWatermark || '').trim(), String(incomingTieBreak || '').trim(), String(existingTieBreak || '').trim());
 }
+function shouldSkipTaskClassification(op) {
+    return (op === 'delete'
+        || op === 'initiative-upsert'
+        || op === 'workstream-upsert'
+        || op === 'document-upsert'
+        || op === 'document-delete'
+        || op === 'asset-upsert'
+        || op === 'asset-delete'
+        || op === 'document-review-session-upsert'
+        || op === 'document-review-session-delete'
+        || op === 'document-review-comment-upsert'
+        || op === 'document-review-comment-delete'
+        || op === 'annotated-attachment-session-upsert'
+        || op === 'annotated-attachment-session-delete');
+}
+function recordTaskReferenceNumberMismatch(input) {
+    const { core, workspaceId, task, recordSyncDiagnostic, } = input;
+    const taskId = String(task?.id || '').trim();
+    const incomingReferenceNumber = Number.isFinite(Number(task?.referenceNumber))
+        ? Math.max(1, Math.floor(Number(task?.referenceNumber)))
+        : null;
+    if (!incomingReferenceNumber)
+        return false;
+    const existingTask = core.resolveTaskIdentifier(`T-${incomingReferenceNumber}`, workspaceId);
+    if (!existingTask || existingTask.id === taskId)
+        return false;
+    recordSyncDiagnostic(workspaceId, 'apply', 'Detected task reference number mismatch during normal sync.', {
+        source: 'tasks.referenceNumber.mismatch',
+        taskId: taskId || null,
+        taskTitle: typeof task?.title === 'string' ? task.title.trim() || null : null,
+        existingTaskId: existingTask.id,
+        existingTaskTitle: existingTask.title || null,
+        referenceLabel: `T-${incomingReferenceNumber}`,
+        existingReferenceNumber: existingTask.referenceNumber ?? incomingReferenceNumber,
+        incomingReferenceNumber
+    });
+    return true;
+}
+export function classifyWorkspaceSyncChanges(input) {
+    const { workspaceId, incomingChanges, normalizeWorkspaceSyncDocumentPath, normalizeTaskAssetPath, normalizeIncomingAiProfileSurfaceType, normalizeTaskEventSyncPayload, recordSyncDiagnostic, } = input;
+    const model = createIncomingApplyModel();
+    for (const change of incomingChanges) {
+        const raw = change;
+        const op = String(raw.op || '').trim().toLowerCase();
+        if (op === 'taxonomy-upsert') {
+            const taxonomy = normalizeTaxonomySyncPayload(raw);
+            if (taxonomy?.taxonomyState)
+                model.planning.incomingTaxonomyState = taxonomy.taxonomyState;
+            if (Array.isArray(taxonomy?.taxonomies))
+                model.planning.incomingTaxonomies = taxonomy.taxonomies;
+            if (taxonomy?.updatedAt)
+                model.planning.incomingTaxonomiesUpdatedAt = taxonomy.updatedAt;
+            continue;
+        }
+        if (op === 'initiative-upsert') {
+            const initiative = normalizeInitiativeSyncPayload(raw.initiative, String(raw.updatedAt || raw.watermark || '').trim());
+            if (initiative)
+                model.planning.incomingInitiatives.set(initiative.id, initiative);
+            continue;
+        }
+        if (op === 'workstream-upsert') {
+            const workstream = normalizeWorkstreamSyncPayload(raw.workstream, String(raw.updatedAt || raw.watermark || '').trim());
+            if (workstream)
+                model.planning.incomingWorkstreams.set(workstream.id, workstream);
+            continue;
+        }
+        if (op === 'ai-profile-upsert') {
+            const profile = normalizeAiProfileSyncPayload(raw.profile, workspaceId, normalizeIncomingAiProfileSurfaceType, 'apply.aiProfileUpsert');
+            const profileId = String(profile?.id || '').trim();
+            if (profileId && profile) {
+                const profileWorkspaceId = String(profile.workspaceId || '').trim();
+                if (profileWorkspaceId && profileWorkspaceId !== workspaceId) {
+                    recordSyncDiagnostic(workspaceId, 'apply', `Rejected ai-profile-upsert for profile ${profileId}: workspace mismatch (expected ${workspaceId}, got ${profileWorkspaceId}).`, {
+                        source: 'apply.aiProfileWorkspaceMismatch',
+                        workspaceId,
+                        profileId,
+                        expectedWorkspaceId: workspaceId,
+                        receivedWorkspaceId: profileWorkspaceId
+                    });
+                    continue;
+                }
+                model.profiles.incomingAiProfiles.set(profileId, {
+                    ...profile,
+                    workspaceId,
+                    createdAt: profile.createdAt || String(raw.updatedAt || raw.watermark || '').trim(),
+                    updatedAt: profile.updatedAt || String(raw.updatedAt || raw.watermark || '').trim(),
+                });
+            }
+            continue;
+        }
+        if (op === 'document-upsert') {
+            const document = normalizeDocumentSyncPayload(raw, normalizeWorkspaceSyncDocumentPath);
+            if (document)
+                model.content.incomingDocuments.push(document);
+            continue;
+        }
+        if (op === 'document-delete') {
+            const deletedDocument = normalizeDocumentDeleteSyncPayload(raw, normalizeWorkspaceSyncDocumentPath);
+            if (deletedDocument)
+                model.content.incomingDocumentDeletes.set(deletedDocument.path, deletedDocument.deletedAt);
+            continue;
+        }
+        if (op === 'asset-upsert') {
+            const asset = normalizeBinaryAssetSyncPayload(raw, normalizeTaskAssetPath);
+            if (asset)
+                model.content.incomingAssets.push(asset);
+            continue;
+        }
+        if (op === 'asset-delete') {
+            const deletedAsset = normalizeBinaryAssetDeleteSyncPayload(raw, normalizeTaskAssetPath);
+            if (deletedAsset)
+                model.content.incomingAssetDeletes.set(deletedAsset.path, deletedAsset.deletedAt);
+            continue;
+        }
+        if (op === 'document-review-session-upsert') {
+            const session = normalizeDocumentReviewSessionSyncPayload(raw.session, String(raw.updatedAt || raw.watermark || '').trim());
+            if (session)
+                model.collaboration.incomingDocumentReviewSessions.set(session.id, session);
+            continue;
+        }
+        if (op === 'document-review-session-delete') {
+            const deletedSession = normalizeDeleteSyncPayload(raw, 'sessionId');
+            if (deletedSession)
+                model.collaboration.incomingDocumentReviewSessionDeletes.set(deletedSession.id, deletedSession.deletedAt);
+            continue;
+        }
+        if (op === 'document-review-comment-upsert') {
+            const comment = normalizeDocumentReviewCommentSyncPayload(raw.comment, { sourceWatermark: String(raw.updatedAt || raw.watermark || '').trim() });
+            if (comment)
+                model.collaboration.incomingDocumentReviewComments.set(comment.id, comment);
+            continue;
+        }
+        if (op === 'document-review-comment-delete') {
+            const deletedComment = normalizeDeleteSyncPayload(raw, 'commentId');
+            if (deletedComment)
+                model.collaboration.incomingDocumentReviewCommentDeletes.set(deletedComment.id, deletedComment.deletedAt);
+            continue;
+        }
+        if (op === 'annotated-attachment-session-upsert') {
+            const session = normalizeAnnotatedAttachmentSessionSyncPayload(raw.session, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
+            if (session)
+                model.collaboration.incomingAnnotatedAttachmentSessions.set(session.id, session);
+            continue;
+        }
+        if (op === 'annotated-attachment-session-delete') {
+            const deletedSession = normalizeDeleteSyncPayload(raw, 'sessionId');
+            if (deletedSession)
+                model.collaboration.incomingAnnotatedAttachmentSessionDeletes.set(deletedSession.id, deletedSession.deletedAt);
+            continue;
+        }
+        if (op === 'task-event-upsert') {
+            const event = normalizeTaskEventSyncPayload(raw.event, workspaceId, String(raw.updatedAt || raw.watermark || '').trim());
+            if (event)
+                model.taskActivity.incomingTaskEvents.set(event.id, event);
+            continue;
+        }
+        if (op !== 'delete')
+            continue;
+        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());
+        }
+    }
+    for (const change of incomingChanges) {
+        const raw = change;
+        const op = String(raw.op || '').trim().toLowerCase();
+        if (shouldSkipTaskClassification(op))
+            continue;
+        const task = normalizeTaskSyncPayload(raw.task);
+        if (!task)
+            continue;
+        model.taskMutations.upserts.push({
+            archived: raw.archived === true || task.isArchived === true,
+            task,
+        });
+    }
+    return model;
+}
+export function prepareTaskSyncSnapshotApply(input) {
+    const { core, workspaceId, taskMutations, recordSyncDiagnostic, } = input;
+    const prepared = {
+        tasks: [],
+        archived: [],
+    };
+    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() : '';
+        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)
+            prepared.archived.push(task);
+        else
+            prepared.tasks.push(task);
+    }
+    return prepared;
+}
+export function applyTaskSyncDeletes(input) {
+    const { core, workspaceId, taskMutations, recordSyncDiagnostic, } = input;
+    for (const [taskId, deleteWatermark] of taskMutations.deletes.entries()) {
+        try {
+            const existingTask = core.getTask(taskId, workspaceId);
+            if (existingTask) {
+                const compareAgainstExisting = resolveSyncConflictOrdering(deleteWatermark, getTaskMutationWatermark(existingTask), `delete:${taskId}`, getTaskMutationTieBreak(existingTask, Boolean(existingTask.isArchived)));
+                if (compareAgainstExisting < 0)
+                    continue;
+            }
+            core.deleteTaskForSync(taskId, workspaceId, { persistBackup: false });
+        }
+        catch (error) {
+            recordSyncDiagnostic(workspaceId, 'apply', 'Failed to delete task during sync apply.', {
+                source: 'apply.deleteTask',
+                taskId,
+                error: String(error?.message || error || '')
+            });
+        }
+    }
+    return taskMutations.deletes.size;
+}
+export function applyPreparedTaskSyncSnapshot(input) {
+    const { core, workspaceId, prepared, } = input;
+    return core.applyWorkspaceSyncSnapshot({
+        tasks: prepared.tasks.map(taskSyncPayloadToCoreTask),
+        archived: prepared.archived.map(taskSyncPayloadToCoreTask)
+    }, workspaceId);
+}
 export function applyPlanningSyncChanges(input) {
     const { core, workspaceId, incomingInitiatives, incomingWorkstreams, incomingTaxonomies, incomingTaxonomyState, incomingTaxonomiesUpdatedAt, workspaceTaxonomySyncMeta, recordSyncDiagnostic, } = input;
     if (incomingInitiatives.size > 0) {
@@ -107,6 +382,10 @@ export function applyAiProfileAndMemberSyncChanges(input) {
                     username: profile.username,
                     icon: profile.icon,
                     color: profile.color,
+                    description: profile.description ?? null,
+                    role: profile.role ?? null,
+                    provider: profile.provider ?? null,
+                    model: profile.model ?? null,
                     surfaceType: profile.surfaceType,
                     providerMetadata: profile.providerMetadata,
                     createdAt: profile.createdAt,
@@ -150,21 +429,29 @@ export function applyAiProfileAndMemberSyncChanges(input) {
     }
 }
 export async function applyContentSyncChanges(input) {
-    const { core, workspaceId, incomingDocuments, incomingDocumentDeletes, incomingAssets, incomingAssetDeletes, basePath, hasObjectStorageClient, hasDocumentSyncMetadataDrift, hasBinaryAssetSyncMetadataDrift, 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, } = input;
     if (incomingDocuments.length > 0) {
         for (const doc of incomingDocuments) {
             try {
                 const existingDoc = core.getDocumentWatermark(workspaceId, doc.path);
+                const existingDocFallback = getExistingDocument ? getExistingDocument(doc.path, workspaceId) : null;
+                const localDocumentPath = path.resolve(basePath, doc.path);
+                const localDocumentHash = !hasObjectStorageClient() && fs.existsSync(localDocumentPath)
+                    ? createHash('sha256').update(fs.readFileSync(localDocumentPath, 'utf8')).digest('hex')
+                    : '';
                 const incomingHash = createHash('sha256').update(String(doc.content || '')).digest('hex');
-                const existingUpdatedAt = String(existingDoc?.updatedAt || '').trim();
-                const existingHash = String(existingDoc?.contentHash || '').trim();
+                const existingUpdatedAt = String(existingDoc?.updatedAt || existingDocFallback?.updatedAt || '').trim();
+                const existingHash = String(existingDoc?.contentHash || localDocumentHash || existingDocFallback?.contentHash || '').trim();
                 const compare = resolveSyncConflictOrdering(doc.updatedAt, existingUpdatedAt, incomingHash, existingHash);
                 const metadataDrift = hasDocumentSyncMetadataDrift(workspaceId, doc, options);
                 if (compare < 0)
                     continue;
                 if (compare === 0 && existingHash === incomingHash && !metadataDrift)
                     continue;
-                await writeWorkspaceSyncDocument(basePath, doc, workspaceId, options);
+                await writeWorkspaceSyncDocument(basePath, doc, workspaceId, {
+                    ...options,
+                    allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true || existingHash !== incomingHash
+                });
             }
             catch (error) {
                 recordSyncDiagnostic(workspaceId, 'apply', 'Failed to apply synced document change.', {
@@ -190,18 +477,27 @@ export async function applyContentSyncChanges(input) {
     if (incomingAssets.length > 0) {
         for (const asset of incomingAssets) {
             try {
+                const localAssetPath = path.resolve(basePath, asset.path);
                 const existing = getExistingBinaryAsset(asset.path, workspaceId);
                 const incomingHash = createHash('sha256').update(Buffer.from(String(asset.contentBase64 || ''), 'base64')).digest('hex');
+                const localFileMissing = !hasObjectStorageClient() && !fs.existsSync(localAssetPath);
+                const localAssetHash = !hasObjectStorageClient() && !localFileMissing
+                    ? createHash('sha256').update(fs.readFileSync(localAssetPath)).digest('hex')
+                    : '';
                 const existingUpdatedAt = String(existing?.updatedAt || '').trim();
-                const existingHash = String(existing?.contentSha256 || '').trim();
-                const localFileMissing = !hasObjectStorageClient() && !fs.existsSync(path.resolve(basePath, asset.path));
+                const existingHash = String(localAssetHash || existing?.contentSha256 || '').trim();
                 const compare = resolveSyncConflictOrdering(asset.updatedAt, existingUpdatedAt, incomingHash, existingHash);
                 const metadataDrift = hasBinaryAssetSyncMetadataDrift(workspaceId, asset, options);
                 if (compare < 0)
                     continue;
                 if (compare === 0 && existingHash === incomingHash && !localFileMissing && !metadataDrift)
                     continue;
-                await writeWorkspaceSyncBinaryAsset(basePath, asset, workspaceId, options);
+                await writeWorkspaceSyncBinaryAsset(basePath, asset, workspaceId, {
+                    ...options,
+                    allowReferenceNumberReassignment: options?.allowReferenceNumberReassignment === true
+                        || existingHash !== incomingHash
+                        || localFileMissing
+                });
             }
             catch (error) {
                 recordSyncDiagnostic(workspaceId, 'apply', 'Failed to apply synced asset change.', {
@@ -443,3 +739,69 @@ export function applyCollaborationSyncChanges(input) {
         }
     }
 }
+export function applyTaskActivitySyncChanges(input) {
+    const { core, workspaceId, incomingTaskEvents, recordSyncDiagnostic, createSyncRouteError, } = input;
+    if (incomingTaskEvents.size <= 0)
+        return;
+    for (const event of incomingTaskEvents.values()) {
+        try {
+            const taskId = String(event.taskId || '').trim();
+            if (!taskId)
+                continue;
+            const existingTask = core.getTask(taskId, workspaceId);
+            if (!existingTask) {
+                recordSyncDiagnostic(workspaceId, 'apply', 'Skipped task event during sync apply because the task does not exist locally.', {
+                    source: 'apply.taskEventMissingTask',
+                    eventId: event.id,
+                    taskId,
+                });
+                continue;
+            }
+            const existing = core.listTaskEvents(taskId, workspaceId).find((entry) => entry.id === event.id) || null;
+            const incomingTieBreak = createHash('sha256')
+                .update(JSON.stringify({
+                taskId,
+                action: event.action,
+                actor: event.actor,
+                actorType: event.actorType,
+                details: event.details ?? {},
+            }))
+                .digest('hex');
+            const existingTieBreak = existing
+                ? createHash('sha256')
+                    .update(JSON.stringify({
+                    taskId: existing.taskId,
+                    action: existing.action,
+                    actor: existing.actor,
+                    actorType: existing.actorType,
+                    details: existing.details ?? {},
+                }))
+                    .digest('hex')
+                : '';
+            const compare = resolveSyncConflictOrdering(event.createdAt, String(existing?.createdAt || '').trim(), incomingTieBreak, existingTieBreak);
+            if (compare < 0)
+                continue;
+            core.upsertTaskEventForSync({
+                id: event.id,
+                taskId,
+                workspaceId,
+                action: event.action,
+                actor: event.actor,
+                actorType: event.actorType,
+                details: event.details,
+                createdAt: event.createdAt,
+            });
+        }
+        catch (error) {
+            const details = {
+                source: 'apply.taskEventUpsert',
+                eventId: event.id,
+                taskId: event.taskId,
+                error: String(error?.message || error || ''),
+                errorCode: String(error?.code || '').trim() || null
+            };
+            recordSyncDiagnostic(workspaceId, 'apply', 'Failed to upsert task event during sync apply.', details);
+            throw createSyncRouteError(`Failed to persist task event ${event.id} during sync apply: ${String(error?.message || error || 'Unknown error')}`, details, { code: 'TASK_EVENT_SYNC_APPLY_FAILED', statusCode: 500 });
+        }
+    }
+}

package/dist/sync/syncApplyHandlers.test.d.ts

@@ -0,0 +1 @@
+export {};