@taskforcehq/taskforce 0.3.305 → 0.3.306

package/dist/sync/workspaceRepair.js

@@ -338,8 +338,9 @@ export function scanWorkspaceRepair(input) {
         for (const asset of assets) {
             const links = input.workspaceAssetStore.listLinksForAsset(asset.assetId, snapshot.workspaceId, { includeDeleted: false });
             for (const link of links) {
-                if (activeTaskIds.has(link.taskId))
+                if (link.targetType === 'task' && link.taskId && activeTaskIds.has(link.taskId))
                     continue;
+                const linkedTargetId = link.targetId;
                 issues.push({
                     code: 'stale_asset_link',
                     entityKind: 'link',
@@ -349,7 +350,9 @@ export function scanWorkspaceRepair(input) {
                     role: link.role,
                     repairable: true,
                     recommendedAction: 'delete-link',
-                    detail: 'Canonical asset link points to a task that no longer exists in this workspace.'
+                    detail: link.targetType === 'task'
+                        ? 'Canonical asset link points to a task that no longer exists in this workspace.'
+                        : `Canonical asset link points to a missing ${link.targetType} target (${linkedTargetId}).`
                 });
             }
         }

package/dist/sync/workspaceSyncModel.d.ts

@@ -3,6 +3,7 @@ import type { DocumentReviewCommentRecord, DocumentReviewSessionStatus } from '.
 import type { AnnotatedAttachmentAnnotation } from '../annotatedAttachments/types.js';
 import type { WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
 import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import { type AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 import { type TaskSyncPayload } from './taskSyncPayload.js';
 export type WorkspaceSyncTaskSnapshot = TaskSyncPayload;
 export interface WorkspaceSyncTaskEventSnapshot {
@@ -23,12 +24,20 @@ export interface WorkspaceSyncAiProfileSnapshot {
     username: string;
     icon: string;
     color: string;
+    avatarUrl?: string | null;
+    avatarSourceUrl?: string | null;
     description?: string | null;
     role?: string | null;
     provider?: string | null;
     model?: string | null;
     surfaceType?: AiProfileSurfaceType | null;
+    seatScope?: AiProfileSeatScope | null;
     providerMetadata?: Record<string, unknown> | null;
+    archivedAt?: string | null;
+    archivedBy?: string | null;
+    archivedReason?: string | null;
+    mergedIntoProfileId?: string | null;
+    rosterStateUpdatedAt?: string | null;
     createdAt: string;
     updatedAt: string;
     lastActiveAt?: string | null;
@@ -200,6 +209,8 @@ export type WorkspaceSyncChange = {
 export interface WorkspaceSyncPayload {
     changes: WorkspaceSyncChange[];
     currentTaskIds: Set<string>;
+    currentTaskWatermarks?: Map<string, string>;
+    currentTaskChangeKeys?: Map<string, string>;
     deleteTaskIds: Set<string>;
     currentInitiativeIds: Set<string>;
     currentInitiativeWatermarks: Map<string, string>;
@@ -207,6 +218,7 @@ export interface WorkspaceSyncPayload {
     currentWorkstreamWatermarks: Map<string, string>;
     currentAiProfileIds: Set<string>;
     currentAiProfileWatermarks: Map<string, string>;
+    currentAiProfileChangeKeys?: Map<string, string>;
     currentDocumentPaths: Set<string>;
     deleteDocumentPaths: Set<string>;
     currentDocumentWatermarks: Map<string, string>;
@@ -225,6 +237,34 @@ export interface WorkspaceSyncPayload {
     currentTaskEventWatermarks: Map<string, string>;
     /** Watermarks for every task upsert included in this payload (id → updatedAt|createdAt). */
     pushedWatermarks: Map<string, string>;
+    pushedTaskChangeKeys?: Map<string, string>;
+    deltaDiagnostics?: WorkspaceSyncDeltaDiagnostics;
+}
+export type WorkspaceSyncBaselineResetReason = 'missing-baseline' | 'repair-reset' | 'storage-write-failed';
+export interface WorkspaceSyncDomainDeltaDiagnostics {
+    mode: 'none' | 'delta' | 'send-all';
+    reason: WorkspaceSyncBaselineResetReason | 'full-state-domain' | null;
+    currentCount: number;
+    baselineCount: number;
+    changeCount: number;
+}
+export interface WorkspaceSyncDeltaDiagnostics {
+    totalChanges: number;
+    byOp: Record<string, number>;
+    baselineResetReason: WorkspaceSyncBaselineResetReason | null;
+    domains: {
+        tasks: WorkspaceSyncDomainDeltaDiagnostics;
+        initiatives: WorkspaceSyncDomainDeltaDiagnostics;
+        workstreams: WorkspaceSyncDomainDeltaDiagnostics;
+        aiProfiles: WorkspaceSyncDomainDeltaDiagnostics;
+        documents: WorkspaceSyncDomainDeltaDiagnostics;
+        assets: WorkspaceSyncDomainDeltaDiagnostics;
+        documentReviewSessions: WorkspaceSyncDomainDeltaDiagnostics;
+        documentReviewComments: WorkspaceSyncDomainDeltaDiagnostics;
+        annotatedAttachmentSessions: WorkspaceSyncDomainDeltaDiagnostics;
+        taskEvents: WorkspaceSyncDomainDeltaDiagnostics;
+        taxonomy: WorkspaceSyncDomainDeltaDiagnostics;
+    };
 }
 export declare function toWorkspaceSyncTaskSnapshot(task: TaskItem): WorkspaceSyncTaskSnapshot;
 export interface WorkspaceSyncDocumentSnapshot {
@@ -268,6 +308,8 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     aiProfiles?: WorkspaceSyncAiProfileSnapshot[];
     documents?: WorkspaceSyncDocumentSnapshot[];
     assets?: WorkspaceSyncAssetSnapshot[];
+    currentDocumentPaths?: Iterable<string>;
+    currentAssetPaths?: Iterable<string>;
     documentReviewSessions?: WorkspaceSyncDocumentReviewSessionSnapshot[];
     documentReviewComments?: WorkspaceSyncDocumentReviewCommentSnapshot[];
     annotatedAttachmentSessions?: WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
@@ -289,6 +331,7 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     lastPushedAnnotatedAttachmentSessionIds?: Set<string>;
     lastPushedAnnotatedAttachmentSessionWatermarks?: Map<string, string>;
     lastPushedTaskEventWatermarks?: Map<string, string>;
+    baselineResetReason?: WorkspaceSyncBaselineResetReason | null;
     /**
      * Watermark (updatedAt|createdAt) of each task as of its last successful push.
      * When provided, only tasks whose watermark differs from this map are included
@@ -296,6 +339,8 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
      * Absent or empty map = include all tasks (first-push / full-sync behaviour).
      */
     lastPushedWatermarks?: Map<string, string>;
+    lastPushedTaskChangeKeys?: Map<string, string>;
+    lastPushedAiProfileChangeKeys?: Map<string, string>;
 }): WorkspaceSyncPayload;
 export declare function buildWorkspaceSyncSignatureModel(input: {
     workspaceId: string;

package/dist/sync/workspaceSyncModel.js

@@ -1,8 +1,17 @@
 import { parseAiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import { parseAiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 import { serializeTaskForSync } from './taskSyncPayload.js';
+import { aiProfileSyncResourceAdapter, taskSyncResourceAdapter, shouldSyncResource, } from './syncResourceAdapters.js';
+import { normalizeSyncSameOriginAssetUrl } from './syncFieldSemantics.js';
 export function toWorkspaceSyncTaskSnapshot(task) {
     return serializeTaskForSync(task);
 }
+function normalizeWorkspaceSyncPathSet(value, fallback) {
+    const source = value ?? fallback;
+    return new Set(Array.from(source)
+        .map((entry) => String(entry || '').trim())
+        .filter((entry) => entry.length > 0));
+}
 function sortTaskEventsForSync(taskEvents) {
     return [...taskEvents].sort((left, right) => {
         const leftCreatedAt = String(left?.createdAt || '').trim();
@@ -29,49 +38,62 @@ export function buildWorkspaceSyncPayloadModel(input) {
         .map(([taskId, deletedAt]) => [String(taskId || '').trim(), String(deletedAt || '').trim()])
         .filter(([taskId, deletedAt]) => taskId.length > 0 && Number.isFinite(Date.parse(deletedAt))));
     const lastWatermarks = input.lastPushedWatermarks;
-    const isDirty = (task) => {
+    const lastTaskChangeKeys = input.lastPushedTaskChangeKeys;
+    const isDirty = (task, archived) => {
         if ((task?.referenceNumber === undefined || task?.referenceNumber === null) && Number.isFinite(Number(task?.localReferenceNumber))) {
             return true;
         }
-        if (!lastWatermarks || lastWatermarks.size === 0)
-            return true;
-        const taskId = String(task?.id || '').trim();
-        if (!taskId)
-            return false;
-        const currentWatermark = String(task?.updatedAt || task?.createdAt || '').trim();
-        return lastWatermarks.get(taskId) !== currentWatermark;
+        return shouldSyncResource(taskSyncResourceAdapter, { ...task, isArchived: archived }, {
+            watermarks: lastWatermarks,
+            changeKeys: lastTaskChangeKeys,
+        });
     };
     const activeTasksOrdered = sortTasksForSync(input.tasks || []);
     const archivedTasksOrdered = sortTasksForSync(input.archivedTasks || []);
+    const currentTaskWatermarks = new Map();
+    const currentTaskChangeKeys = new Map();
     const pushedWatermarks = new Map();
+    const pushedTaskChangeKeys = new Map();
     const activeChanges = activeTasksOrdered
-        .filter((task) => !pendingDeleteIds.has(String(task?.id || '').trim()) && isDirty(task))
+        .filter((task) => !pendingDeleteIds.has(String(task?.id || '').trim()) && isDirty(task, false))
         .map((task) => {
         const taskId = String(task?.id || '').trim();
-        const wm = String(task?.updatedAt || task?.createdAt || '').trim();
-        if (taskId)
+        const wm = taskSyncResourceAdapter.getWatermark(task);
+        const changeKey = taskSyncResourceAdapter.getChangeKey({ ...task, isArchived: false });
+        if (taskId) {
             pushedWatermarks.set(taskId, wm);
+            pushedTaskChangeKeys.set(taskId, changeKey);
+        }
         return { op: 'upsert', archived: false, task: toWorkspaceSyncTaskSnapshot(task) };
     });
     const archivedChanges = archivedTasksOrdered
-        .filter((task) => !pendingDeleteIds.has(String(task?.id || '').trim()) && isDirty(task))
+        .filter((task) => !pendingDeleteIds.has(String(task?.id || '').trim()) && isDirty(task, true))
         .map((task) => {
         const taskId = String(task?.id || '').trim();
-        const wm = String(task?.updatedAt || task?.createdAt || '').trim();
-        if (taskId)
+        const wm = taskSyncResourceAdapter.getWatermark(task);
+        const changeKey = taskSyncResourceAdapter.getChangeKey({ ...task, isArchived: true });
+        if (taskId) {
             pushedWatermarks.set(taskId, wm);
+            pushedTaskChangeKeys.set(taskId, changeKey);
+        }
         return { op: 'upsert', archived: true, task: toWorkspaceSyncTaskSnapshot(task) };
     });
     const currentTaskIds = new Set();
     for (const task of input.tasks || []) {
         const taskId = String(task?.id || '').trim();
-        if (taskId)
-            currentTaskIds.add(taskId);
+        if (!taskId)
+            continue;
+        currentTaskIds.add(taskId);
+        currentTaskWatermarks.set(taskId, taskSyncResourceAdapter.getWatermark(task));
+        currentTaskChangeKeys.set(taskId, taskSyncResourceAdapter.getChangeKey({ ...task, isArchived: false }));
     }
     for (const task of input.archivedTasks || []) {
         const taskId = String(task?.id || '').trim();
-        if (taskId)
-            currentTaskIds.add(taskId);
+        if (!taskId)
+            continue;
+        currentTaskIds.add(taskId);
+        currentTaskWatermarks.set(taskId, taskSyncResourceAdapter.getWatermark(task));
+        currentTaskChangeKeys.set(taskId, taskSyncResourceAdapter.getChangeKey({ ...task, isArchived: true }));
     }
     const deleteChanges = Array.from(input.lastPushedTaskIds)
         .filter((taskId) => !currentTaskIds.has(taskId))
@@ -175,9 +197,13 @@ export function buildWorkspaceSyncPayloadModel(input) {
         .map((profile) => String(profile?.id || '').trim())
         .filter((profileId) => profileId.length > 0));
     const currentAiProfileWatermarks = new Map((Array.isArray(input.aiProfiles) ? input.aiProfiles : [])
-        .map((profile) => [String(profile?.id || '').trim(), String(profile?.updatedAt || profile?.createdAt || '').trim()])
+        .map((profile) => [String(profile?.id || '').trim(), aiProfileSyncResourceAdapter.getWatermark(profile)])
+        .filter(([profileId]) => profileId.length > 0));
+    const currentAiProfileChangeKeys = new Map((Array.isArray(input.aiProfiles) ? input.aiProfiles : [])
+        .map((profile) => [String(profile?.id || '').trim(), aiProfileSyncResourceAdapter.getChangeKey(profile)])
         .filter(([profileId]) => profileId.length > 0));
     const previousAiProfileWatermarks = input.lastPushedAiProfileWatermarks;
+    const previousAiProfileChangeKeys = input.lastPushedAiProfileChangeKeys;
     const shouldSendAllAiProfiles = !previousAiProfileWatermarks || previousAiProfileWatermarks.size === 0;
     const aiProfileUpsertChanges = (Array.isArray(input.aiProfiles) ? input.aiProfiles : [])
         .map((profile) => ({
@@ -190,14 +216,30 @@ export function buildWorkspaceSyncPayloadModel(input) {
             username: String(profile.username || '').trim(),
             icon: String(profile.icon || 'Bot').trim() || 'Bot',
             color: String(profile.color || '#8b5cf6').trim() || '#8b5cf6',
+            avatarUrl: normalizeSyncSameOriginAssetUrl(profile.avatarUrl),
+            avatarSourceUrl: normalizeSyncSameOriginAssetUrl(profile.avatarSourceUrl),
             description: typeof profile.description === 'string' ? profile.description.trim() || null : null,
             role: typeof profile.role === 'string' ? profile.role.trim() || null : null,
             provider: typeof profile.provider === 'string' ? profile.provider.trim() || null : null,
             model: typeof profile.model === 'string' ? profile.model.trim() || null : null,
             surfaceType: parseAiProfileSurfaceType(profile.surfaceType),
+            seatScope: parseAiProfileSeatScope(profile.seatScope),
             providerMetadata: profile.providerMetadata && typeof profile.providerMetadata === 'object' && !Array.isArray(profile.providerMetadata)
                 ? profile.providerMetadata
                 : null,
+            archivedAt: typeof profile.archivedAt === 'string' && profile.archivedAt.trim().length > 0
+                ? profile.archivedAt.trim()
+                : null,
+            archivedBy: typeof profile.archivedBy === 'string' && profile.archivedBy.trim().length > 0
+                ? profile.archivedBy.trim()
+                : null,
+            archivedReason: typeof profile.archivedReason === 'string' ? profile.archivedReason.trim() || null : null,
+            mergedIntoProfileId: typeof profile.mergedIntoProfileId === 'string' && profile.mergedIntoProfileId.trim().length > 0
+                ? profile.mergedIntoProfileId.trim()
+                : null,
+            rosterStateUpdatedAt: typeof profile.rosterStateUpdatedAt === 'string' && profile.rosterStateUpdatedAt.trim().length > 0
+                ? profile.rosterStateUpdatedAt.trim()
+                : null,
             createdAt: String(profile.createdAt || '').trim(),
             updatedAt: String(profile.updatedAt || profile.createdAt || '').trim(),
             lastActiveAt: typeof profile.lastActiveAt === 'string' && profile.lastActiveAt.trim().length > 0
@@ -209,11 +251,13 @@ export function buildWorkspaceSyncPayloadModel(input) {
         .filter((change) => {
         if (shouldSendAllAiProfiles)
             return true;
-        return previousAiProfileWatermarks.get(change.profile.id) !== change.profile.updatedAt;
+        return shouldSyncResource(aiProfileSyncResourceAdapter, change.profile, {
+            watermarks: previousAiProfileWatermarks,
+            changeKeys: previousAiProfileChangeKeys,
+        });
     });
-    const currentDocumentPaths = new Set((Array.isArray(input.documents) ? input.documents : [])
-        .map((doc) => String(doc?.path || '').trim())
-        .filter((docPath) => docPath.length > 0));
+    const currentDocumentPaths = normalizeWorkspaceSyncPathSet(input.currentDocumentPaths, (Array.isArray(input.documents) ? input.documents : [])
+        .map((doc) => String(doc?.path || '').trim()));
     const deleteDocumentPaths = new Set(Array.from(input.lastPushedDocumentPaths || new Set())
         .map((docPath) => String(docPath || '').trim())
         .filter((docPath) => docPath.length > 0 && !currentDocumentPaths.has(docPath)));
@@ -244,9 +288,8 @@ export function buildWorkspaceSyncPayloadModel(input) {
             return true;
         return previousDocumentWatermarks.get(doc.path) !== doc.updatedAt;
     });
-    const currentAssetPaths = new Set((Array.isArray(input.assets) ? input.assets : [])
-        .map((asset) => String(asset?.path || '').trim())
-        .filter((assetPath) => assetPath.length > 0));
+    const currentAssetPaths = normalizeWorkspaceSyncPathSet(input.currentAssetPaths, (Array.isArray(input.assets) ? input.assets : [])
+        .map((asset) => String(asset?.path || '').trim()));
     const deleteAssetPaths = new Set(Array.from(input.lastPushedAssetPaths || new Set())
         .map((assetPath) => String(assetPath || '').trim())
         .filter((assetPath) => assetPath.length > 0 && !currentAssetPaths.has(assetPath)));
@@ -500,9 +543,46 @@ export function buildWorkspaceSyncPayloadModel(input) {
             deletedAt: pendingDeleteWatermarks.get(taskId) || payloadBuiltAt
         }))
     ];
+    const baselineResetReason = input.baselineResetReason ?? null;
+    const resolveDomainDeltaDiagnostics = (args) => {
+        const changeCount = args.upsertCount + (args.deleteCount || 0);
+        if (args.currentCount === 0 && changeCount === 0) {
+            return {
+                mode: 'none',
+                reason: null,
+                currentCount: 0,
+                baselineCount: args.baselineCount,
+                changeCount
+            };
+        }
+        if (args.alwaysFull) {
+            return {
+                mode: changeCount > 0 ? 'send-all' : 'none',
+                reason: changeCount > 0 ? 'full-state-domain' : null,
+                currentCount: args.currentCount,
+                baselineCount: args.baselineCount,
+                changeCount
+            };
+        }
+        const shouldSendAll = args.baselineCount === 0 && args.currentCount > 0 && args.upsertCount >= args.currentCount;
+        return {
+            mode: shouldSendAll ? 'send-all' : 'delta',
+            reason: shouldSendAll ? (baselineResetReason || 'missing-baseline') : null,
+            currentCount: args.currentCount,
+            baselineCount: args.baselineCount,
+            changeCount
+        };
+    };
+    const byOp = changes.reduce((acc, change) => {
+        const op = String(change.op || '').trim();
+        acc[op] = (acc[op] || 0) + 1;
+        return acc;
+    }, {});
     return {
         changes,
         currentTaskIds: new Set(Array.from(currentTaskIds).filter((taskId) => !pendingDeleteIds.has(taskId))),
+        currentTaskWatermarks: new Map(Array.from(currentTaskWatermarks.entries()).filter(([taskId]) => !pendingDeleteIds.has(taskId))),
+        currentTaskChangeKeys: new Map(Array.from(currentTaskChangeKeys.entries()).filter(([taskId]) => !pendingDeleteIds.has(taskId))),
         deleteTaskIds,
         currentInitiativeIds,
         currentInitiativeWatermarks,
@@ -510,6 +590,7 @@ export function buildWorkspaceSyncPayloadModel(input) {
         currentWorkstreamWatermarks,
         currentAiProfileIds,
         currentAiProfileWatermarks,
+        currentAiProfileChangeKeys,
         currentDocumentPaths,
         deleteDocumentPaths,
         currentDocumentWatermarks,
@@ -526,7 +607,77 @@ export function buildWorkspaceSyncPayloadModel(input) {
         deleteAnnotatedAttachmentSessionIds,
         currentAnnotatedAttachmentSessionWatermarks,
         currentTaskEventWatermarks,
-        pushedWatermarks
+        pushedWatermarks,
+        pushedTaskChangeKeys,
+        deltaDiagnostics: {
+            totalChanges: changes.length,
+            byOp,
+            baselineResetReason,
+            domains: {
+                tasks: resolveDomainDeltaDiagnostics({
+                    currentCount: currentTaskIds.size,
+                    baselineCount: lastWatermarks?.size || 0,
+                    upsertCount: activeChanges.length + archivedChanges.length,
+                    deleteCount: deleteTaskIds.size
+                }),
+                initiatives: resolveDomainDeltaDiagnostics({
+                    currentCount: currentInitiativeIds.size,
+                    baselineCount: previousInitiativeWatermarks?.size || 0,
+                    upsertCount: initiativeUpsertChanges.length
+                }),
+                workstreams: resolveDomainDeltaDiagnostics({
+                    currentCount: currentWorkstreamIds.size,
+                    baselineCount: previousWorkstreamWatermarks?.size || 0,
+                    upsertCount: workstreamUpsertChanges.length
+                }),
+                aiProfiles: resolveDomainDeltaDiagnostics({
+                    currentCount: currentAiProfileIds.size,
+                    baselineCount: previousAiProfileWatermarks?.size || 0,
+                    upsertCount: aiProfileUpsertChanges.length
+                }),
+                documents: resolveDomainDeltaDiagnostics({
+                    currentCount: currentDocumentPaths.size,
+                    baselineCount: previousDocumentWatermarks?.size || 0,
+                    upsertCount: documentUpsertChanges.length,
+                    deleteCount: deleteDocumentPaths.size
+                }),
+                assets: resolveDomainDeltaDiagnostics({
+                    currentCount: currentAssetPaths.size,
+                    baselineCount: previousAssetWatermarks?.size || 0,
+                    upsertCount: assetUpsertChanges.length,
+                    deleteCount: deleteAssetPaths.size
+                }),
+                documentReviewSessions: resolveDomainDeltaDiagnostics({
+                    currentCount: currentDocumentReviewSessionIds.size,
+                    baselineCount: previousDocumentReviewSessionWatermarks?.size || 0,
+                    upsertCount: documentReviewSessionUpsertChanges.length,
+                    deleteCount: deleteDocumentReviewSessionIds.size
+                }),
+                documentReviewComments: resolveDomainDeltaDiagnostics({
+                    currentCount: currentDocumentReviewCommentIds.size,
+                    baselineCount: previousDocumentReviewCommentWatermarks?.size || 0,
+                    upsertCount: documentReviewCommentUpsertChanges.length,
+                    deleteCount: deleteDocumentReviewCommentIds.size
+                }),
+                annotatedAttachmentSessions: resolveDomainDeltaDiagnostics({
+                    currentCount: currentAnnotatedAttachmentSessionIds.size,
+                    baselineCount: previousAnnotatedAttachmentSessionWatermarks?.size || 0,
+                    upsertCount: annotatedAttachmentSessionUpsertChanges.length,
+                    deleteCount: deleteAnnotatedAttachmentSessionIds.size
+                }),
+                taskEvents: resolveDomainDeltaDiagnostics({
+                    currentCount: currentTaskEventWatermarks.size,
+                    baselineCount: previousTaskEventWatermarks?.size || 0,
+                    upsertCount: taskEventUpsertChanges.length
+                }),
+                taxonomy: resolveDomainDeltaDiagnostics({
+                    currentCount: (input.taxonomyState && typeof input.taxonomyState === 'object') || Array.isArray(input.taxonomies) ? 1 : 0,
+                    baselineCount: 0,
+                    upsertCount: byOp['taxonomy-upsert'] || 0,
+                    alwaysFull: true
+                })
+            }
+        }
     };
 }
 export function buildWorkspaceSyncSignatureModel(input) {
@@ -570,7 +721,11 @@ export function buildWorkspaceSyncSignatureModel(input) {
                 id: String(profile.id || '').trim(),
                 updatedAt: String(profile.updatedAt || profile.createdAt || '').trim(),
                 name: String(profile.name || '').trim(),
-                username: String(profile.username || '').trim()
+                username: String(profile.username || '').trim(),
+                archivedAt: String(profile.archivedAt || '').trim(),
+                archivedReason: String(profile.archivedReason || '').trim(),
+                mergedIntoProfileId: String(profile.mergedIntoProfileId || '').trim(),
+                rosterStateUpdatedAt: String(profile.rosterStateUpdatedAt || '').trim()
             }))
                 .filter((profile) => profile.id.length > 0)
                 .sort((a, b) => a.id.localeCompare(b.id))