@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/hooks/sync/orchestratorShared.js

@@ -1,4 +1,6 @@
 import { parseAiProfileSurfaceType } from '../../shared/aiProfileSurfaceType.js';
+import { parseAiProfileSeatScope } from '../../shared/aiProfileSeatScope.js';
+import { normalizeSyncNullableId, normalizeSyncNullableIsoString, normalizeSyncNullableString, normalizeSyncSameOriginAssetUrl, } from '../../sync/syncFieldSemantics.js';
 export const USER_GLOBAL_SYNC_META_KEY = 'taskforce.userGlobalSyncMeta.v1';
 export const SYNC_DEBUG_LOG_KEY = 'taskforce.syncDebug.v1';
 export const WORKSPACE_BOOTSTRAP_TIMEOUT_MS = 120_000;
@@ -36,29 +38,25 @@ export function normalizeWorkspaceSyncAiProfileSnapshotEntry(entry) {
         username: String(entry?.username || '').trim(),
         icon: String(entry?.icon || 'Bot').trim() || 'Bot',
         color: String(entry?.color || '#8b5cf6').trim() || '#8b5cf6',
-        description: typeof entry?.description === 'string' && entry.description.trim().length > 0
-            ? entry.description.trim()
-            : null,
-        role: typeof entry?.role === 'string' && entry.role.trim().length > 0
-            ? entry.role.trim()
-            : null,
-        provider: typeof entry?.provider === 'string' && entry.provider.trim().length > 0
-            ? entry.provider.trim()
-            : null,
-        model: typeof entry?.model === 'string' && entry.model.trim().length > 0
-            ? entry.model.trim()
-            : null,
+        avatarUrl: normalizeSyncSameOriginAssetUrl(entry?.avatarUrl ?? entry?.avatar_url),
+        avatarSourceUrl: normalizeSyncSameOriginAssetUrl(entry?.avatarSourceUrl ?? entry?.avatar_source_url),
+        description: normalizeSyncNullableString(entry?.description),
+        role: normalizeSyncNullableString(entry?.role),
+        provider: normalizeSyncNullableString(entry?.provider),
+        model: normalizeSyncNullableString(entry?.model),
         surfaceType: parseAiProfileSurfaceType(entry?.surfaceType ?? entry?.surface_type),
+        seatScope: parseAiProfileSeatScope(entry?.seatScope ?? entry?.seat_scope),
         providerMetadata: metadata && typeof metadata === 'object' && !Array.isArray(metadata)
             ? metadata
             : null,
+        archivedAt: normalizeSyncNullableIsoString(entry?.archivedAt ?? entry?.archived_at),
+        archivedBy: normalizeSyncNullableId(entry?.archivedBy ?? entry?.archived_by),
+        archivedReason: normalizeSyncNullableString(entry?.archivedReason ?? entry?.archived_reason),
+        mergedIntoProfileId: normalizeSyncNullableId(entry?.mergedIntoProfileId ?? entry?.merged_into_profile_id),
+        rosterStateUpdatedAt: normalizeSyncNullableIsoString(entry?.rosterStateUpdatedAt ?? entry?.roster_state_updated_at),
         createdAt: String(entry?.createdAt || entry?.created_at || '').trim(),
         updatedAt: String(entry?.updatedAt || entry?.updated_at || entry?.createdAt || entry?.created_at || '').trim(),
-        lastActiveAt: typeof entry?.lastActiveAt === 'string' && entry.lastActiveAt.trim().length > 0
-            ? entry.lastActiveAt.trim()
-            : typeof entry?.last_active_at === 'string' && entry.last_active_at.trim().length > 0
-                ? entry.last_active_at.trim()
-                : null
+        lastActiveAt: normalizeSyncNullableIsoString(entry?.lastActiveAt ?? entry?.last_active_at)
     };
 }
 export function readUserGlobalSyncMeta() {
@@ -150,6 +148,52 @@ export function flattenTaskEvents(tasks, archivedTasks) {
         return left.id.localeCompare(right.id);
     });
 }
+export function buildPersistedSyncWatermarksSnapshot(data) {
+    return {
+        taskIds: Array.from(data.taskIds.values()),
+        taskWatermarks: Array.from(data.taskWatermarks.entries()),
+        taskChangeKeys: Array.from((data.taskChangeKeys || new Map()).entries()),
+        initiativeWatermarks: Array.from(data.initiativeWatermarks.entries()),
+        workstreamWatermarks: Array.from(data.workstreamWatermarks.entries()),
+        aiProfileWatermarks: Array.from(data.aiProfileWatermarks.entries()),
+        aiProfileChangeKeys: Array.from((data.aiProfileChangeKeys || new Map()).entries()),
+        documentWatermarks: Array.from(data.documentWatermarks.entries()),
+        assetWatermarks: Array.from(data.assetWatermarks.entries()),
+        documentReviewSessionWatermarks: Array.from(data.documentReviewSessionWatermarks.entries()),
+        documentReviewCommentWatermarks: Array.from(data.documentReviewCommentWatermarks.entries()),
+        annotatedAttachmentSessionWatermarks: Array.from(data.annotatedAttachmentSessionWatermarks.entries()),
+        taskEventWatermarks: Array.from(data.taskEventWatermarks.entries()),
+        taxonomyStateFingerprint: typeof data.taxonomyStateFingerprint === 'string' ? data.taxonomyStateFingerprint : ''
+    };
+}
+export function parsePersistedSyncWatermarksSnapshot(snapshot, taxonomyStateFingerprint) {
+    if (!snapshot || typeof snapshot !== 'object')
+        return null;
+    const savedTaxonomyStateFingerprint = typeof snapshot.taxonomyStateFingerprint === 'string'
+        ? snapshot.taxonomyStateFingerprint
+        : '';
+    const taskWatermarks = (!taxonomyStateFingerprint || !savedTaxonomyStateFingerprint || savedTaxonomyStateFingerprint === taxonomyStateFingerprint)
+        ? new Map(Array.isArray(snapshot.taskWatermarks) ? snapshot.taskWatermarks : [])
+        : new Map();
+    const taskIds = new Set(Array.isArray(snapshot.taskIds)
+        ? snapshot.taskIds.map((entry) => String(entry || '').trim()).filter((entry) => entry.length > 0)
+        : Array.from(taskWatermarks.keys()));
+    return {
+        taskIds,
+        taskWatermarks,
+        taskChangeKeys: new Map(Array.isArray(snapshot.taskChangeKeys) ? snapshot.taskChangeKeys : []),
+        initiativeWatermarks: new Map(Array.isArray(snapshot.initiativeWatermarks) ? snapshot.initiativeWatermarks : []),
+        workstreamWatermarks: new Map(Array.isArray(snapshot.workstreamWatermarks) ? snapshot.workstreamWatermarks : []),
+        aiProfileWatermarks: new Map(Array.isArray(snapshot.aiProfileWatermarks) ? snapshot.aiProfileWatermarks : []),
+        aiProfileChangeKeys: new Map(Array.isArray(snapshot.aiProfileChangeKeys) ? snapshot.aiProfileChangeKeys : []),
+        documentWatermarks: new Map(Array.isArray(snapshot.documentWatermarks) ? snapshot.documentWatermarks : []),
+        assetWatermarks: new Map(Array.isArray(snapshot.assetWatermarks) ? snapshot.assetWatermarks : []),
+        documentReviewSessionWatermarks: new Map(Array.isArray(snapshot.documentReviewSessionWatermarks) ? snapshot.documentReviewSessionWatermarks : []),
+        documentReviewCommentWatermarks: new Map(Array.isArray(snapshot.documentReviewCommentWatermarks) ? snapshot.documentReviewCommentWatermarks : []),
+        annotatedAttachmentSessionWatermarks: new Map(Array.isArray(snapshot.annotatedAttachmentSessionWatermarks) ? snapshot.annotatedAttachmentSessionWatermarks : []),
+        taskEventWatermarks: new Map(Array.isArray(snapshot.taskEventWatermarks) ? snapshot.taskEventWatermarks : []),
+    };
+}
 export function readPersistedSyncWatermarks(workspaceId, taxonomyStateFingerprint) {
     if (typeof window === 'undefined')
         return null;
@@ -159,25 +203,9 @@ export function readPersistedSyncWatermarks(workspaceId, taxonomyStateFingerprin
         if (!raw)
             return null;
         const parsed = JSON.parse(raw);
-        if (!parsed || (parsed.v !== 2 && parsed.v !== 3 && parsed.v !== 4 && parsed.v !== 5 && parsed.v !== 6 && parsed.v !== 7 && parsed.v !== 8))
+        if (!parsed || (parsed.v !== 2 && parsed.v !== 3 && parsed.v !== 4 && parsed.v !== 5 && parsed.v !== 6 && parsed.v !== 7 && parsed.v !== 8 && parsed.v !== 9 && parsed.v !== 10 && parsed.v !== 11))
             return null;
-        const savedTaxonomyStateFingerprint = typeof parsed.taxonomyStateFingerprint === 'string'
-            ? parsed.taxonomyStateFingerprint
-            : '';
-        const taskWatermarks = (!taxonomyStateFingerprint || !savedTaxonomyStateFingerprint || savedTaxonomyStateFingerprint === taxonomyStateFingerprint)
-            ? new Map(Array.isArray(parsed.taskWatermarks) ? parsed.taskWatermarks : [])
-            : new Map();
-        return {
-            taskWatermarks,
-            initiativeWatermarks: new Map(Array.isArray(parsed.initiativeWatermarks) ? parsed.initiativeWatermarks : []),
-            workstreamWatermarks: new Map(Array.isArray(parsed.workstreamWatermarks) ? parsed.workstreamWatermarks : []),
-            documentWatermarks: new Map(Array.isArray(parsed.documentWatermarks) ? parsed.documentWatermarks : []),
-            assetWatermarks: new Map(Array.isArray(parsed.assetWatermarks) ? parsed.assetWatermarks : []),
-            documentReviewSessionWatermarks: new Map(Array.isArray(parsed.documentReviewSessionWatermarks) ? parsed.documentReviewSessionWatermarks : []),
-            documentReviewCommentWatermarks: new Map(Array.isArray(parsed.documentReviewCommentWatermarks) ? parsed.documentReviewCommentWatermarks : []),
-            annotatedAttachmentSessionWatermarks: new Map(Array.isArray(parsed.annotatedAttachmentSessionWatermarks) ? parsed.annotatedAttachmentSessionWatermarks : []),
-            taskEventWatermarks: new Map(Array.isArray(parsed.taskEventWatermarks) ? parsed.taskEventWatermarks : []),
-        };
+        return parsePersistedSyncWatermarksSnapshot(parsed, taxonomyStateFingerprint);
     }
     catch {
         return null;
@@ -185,25 +213,18 @@ export function readPersistedSyncWatermarks(workspaceId, taxonomyStateFingerprin
 }
 export function savePersistedSyncWatermarks(workspaceId, data) {
     if (typeof window === 'undefined')
-        return;
+        return false;
     try {
         const key = `${WORKSPACE_SYNC_WATERMARKS_KEY_PREFIX}.${workspaceId}`;
         window.localStorage.setItem(key, JSON.stringify({
-            v: 8,
+            v: 11,
             savedAt: new Date().toISOString(),
-            taskWatermarks: Array.from(data.taskWatermarks.entries()),
-            initiativeWatermarks: Array.from(data.initiativeWatermarks.entries()),
-            workstreamWatermarks: Array.from(data.workstreamWatermarks.entries()),
-            documentWatermarks: Array.from(data.documentWatermarks.entries()),
-            assetWatermarks: Array.from(data.assetWatermarks.entries()),
-            documentReviewSessionWatermarks: Array.from(data.documentReviewSessionWatermarks.entries()),
-            documentReviewCommentWatermarks: Array.from(data.documentReviewCommentWatermarks.entries()),
-            annotatedAttachmentSessionWatermarks: Array.from(data.annotatedAttachmentSessionWatermarks.entries()),
-            taskEventWatermarks: Array.from(data.taskEventWatermarks.entries()),
-            taxonomyStateFingerprint: typeof data.taxonomyStateFingerprint === 'string' ? data.taxonomyStateFingerprint : ''
+            ...buildPersistedSyncWatermarksSnapshot(data)
         }));
+        return true;
     }
     catch {
         // localStorage may be full or unavailable; non-fatal
+        return false;
     }
 }

package/dist/hooks/sync/orchestratorShared.test.js

@@ -8,11 +8,13 @@ describe('orchestratorShared sync watermarks', () => {
     it('keeps persisted sync watermarks available across long idle periods', () => {
         const key = `${WORKSPACE_SYNC_WATERMARKS_KEY_PREFIX}.${workspaceId}`;
         localStorage.setItem(key, JSON.stringify({
-            v: 8,
+            v: 9,
             savedAt: '2026-04-14T10:00:00.000Z',
+            taskIds: ['task-1'],
             taskWatermarks: [['task-1', '2026-04-14T09:00:00.000Z']],
             initiativeWatermarks: [['initiative-1', '2026-04-14T09:00:00.000Z']],
             workstreamWatermarks: [],
+            aiProfileWatermarks: [['ai-profile-1', '2026-04-14T09:15:00.000Z']],
             documentWatermarks: [],
             assetWatermarks: [],
             documentReviewSessionWatermarks: [],
@@ -23,15 +25,40 @@ describe('orchestratorShared sync watermarks', () => {
         }));
         const persisted = readPersistedSyncWatermarks(workspaceId, '');
         expect(persisted).not.toBeNull();
+        expect(Array.from(persisted?.taskIds || [])).toEqual(['task-1']);
         expect(persisted?.taskWatermarks.get('task-1')).toBe('2026-04-14T09:00:00.000Z');
         expect(persisted?.initiativeWatermarks.get('initiative-1')).toBe('2026-04-14T09:00:00.000Z');
+        expect(persisted?.aiProfileWatermarks.get('ai-profile-1')).toBe('2026-04-14T09:15:00.000Z');
         expect(persisted?.taskEventWatermarks.get('event-1')).toBe('2026-04-14T09:30:00.000Z');
     });
+    it('persists task and ai-profile change keys alongside legacy watermarks', () => {
+        savePersistedSyncWatermarks(workspaceId, {
+            taskIds: new Set(['task-1']),
+            taskWatermarks: new Map([['task-1', '2026-04-14T09:00:00.000Z']]),
+            taskChangeKeys: new Map([['task-1', 'task-change-key-1']]),
+            initiativeWatermarks: new Map(),
+            workstreamWatermarks: new Map(),
+            aiProfileWatermarks: new Map([['ai-profile-1', '2026-04-14T09:15:00.000Z']]),
+            aiProfileChangeKeys: new Map([['ai-profile-1', 'ai-change-key-1']]),
+            documentWatermarks: new Map(),
+            assetWatermarks: new Map(),
+            documentReviewSessionWatermarks: new Map(),
+            documentReviewCommentWatermarks: new Map(),
+            annotatedAttachmentSessionWatermarks: new Map(),
+            taskEventWatermarks: new Map(),
+            taxonomyStateFingerprint: 'fingerprint-a'
+        });
+        const persisted = readPersistedSyncWatermarks(workspaceId, 'fingerprint-a');
+        expect(persisted?.taskChangeKeys?.get('task-1')).toBe('task-change-key-1');
+        expect(persisted?.aiProfileChangeKeys?.get('ai-profile-1')).toBe('ai-change-key-1');
+    });
     it('still clears task watermarks when the taxonomy fingerprint changes', () => {
         savePersistedSyncWatermarks(workspaceId, {
+            taskIds: new Set(['task-1']),
             taskWatermarks: new Map([['task-1', '2026-04-14T09:00:00.000Z']]),
             initiativeWatermarks: new Map([['initiative-1', '2026-04-14T09:00:00.000Z']]),
             workstreamWatermarks: new Map(),
+            aiProfileWatermarks: new Map([['ai-profile-1', '2026-04-14T09:15:00.000Z']]),
             documentWatermarks: new Map(),
             assetWatermarks: new Map(),
             documentReviewSessionWatermarks: new Map(),
@@ -42,8 +69,30 @@ describe('orchestratorShared sync watermarks', () => {
         });
         const persisted = readPersistedSyncWatermarks(workspaceId, 'fingerprint-b');
         expect(persisted).not.toBeNull();
+        expect(Array.from(persisted?.taskIds || [])).toEqual(['task-1']);
         expect(persisted?.taskWatermarks.size).toBe(0);
         expect(persisted?.initiativeWatermarks.get('initiative-1')).toBe('2026-04-14T09:00:00.000Z');
+        expect(persisted?.aiProfileWatermarks.get('ai-profile-1')).toBe('2026-04-14T09:15:00.000Z');
         expect(persisted?.taskEventWatermarks.get('event-1')).toBe('2026-04-14T09:30:00.000Z');
     });
+    it('falls back to task watermark keys when older persisted snapshots do not have taskIds', () => {
+        const key = `${WORKSPACE_SYNC_WATERMARKS_KEY_PREFIX}.${workspaceId}`;
+        localStorage.setItem(key, JSON.stringify({
+            v: 9,
+            savedAt: '2026-04-14T10:00:00.000Z',
+            taskWatermarks: [['task-legacy-1', '2026-04-14T09:00:00.000Z']],
+            initiativeWatermarks: [],
+            workstreamWatermarks: [],
+            aiProfileWatermarks: [],
+            documentWatermarks: [],
+            assetWatermarks: [],
+            documentReviewSessionWatermarks: [],
+            documentReviewCommentWatermarks: [],
+            annotatedAttachmentSessionWatermarks: [],
+            taskEventWatermarks: [],
+            taxonomyStateFingerprint: ''
+        }));
+        const persisted = readPersistedSyncWatermarks(workspaceId, '');
+        expect(Array.from(persisted?.taskIds || [])).toEqual(['task-legacy-1']);
+    });
 });

package/dist/hooks/sync/pullLifecycle.d.ts

@@ -0,0 +1,31 @@
+import type { WorkspaceSyncPhase } from '../../sync/workspaceSyncState';
+export interface WorkspacePullRequestPlan {
+    bootstrap: boolean;
+    cursor: string | null;
+    successEventType: 'bootstrap' | 'pull';
+}
+interface ResolveWorkspacePullRequestPlanArgs {
+    workspaceSyncPhase: WorkspaceSyncPhase;
+    forceCursorNull?: boolean;
+    currentCursor: string | null;
+}
+interface ResolveWorkspacePullSuccessPlanArgs {
+    workspaceSyncPhase: WorkspaceSyncPhase;
+    forceCursorNull?: boolean;
+    startupFullReconcileRan: boolean;
+    pendingSignature: string;
+    fallbackSignature: string;
+    lastPushedSignature: string;
+}
+export interface WorkspacePullSuccessPlan {
+    successEventType: 'bootstrap' | 'pull';
+    shouldCaptureAttachBootstrapBaseline: boolean;
+    shouldClearPendingSignature: boolean;
+    shouldRefreshReferenceSnapshots: boolean;
+    shouldSeedWorkspaceSnapshotPushBaseline: boolean;
+    shouldScheduleStartupFullReconcile: boolean;
+    deferredPushSignature: string | null;
+}
+export declare function resolveWorkspacePullRequestPlan({ workspaceSyncPhase, forceCursorNull, currentCursor }: ResolveWorkspacePullRequestPlanArgs): WorkspacePullRequestPlan;
+export declare function resolveWorkspacePullSuccessPlan({ workspaceSyncPhase, forceCursorNull, startupFullReconcileRan, pendingSignature, fallbackSignature, lastPushedSignature }: ResolveWorkspacePullSuccessPlanArgs): WorkspacePullSuccessPlan;
+export {};

package/dist/hooks/sync/pullLifecycle.js

@@ -0,0 +1,24 @@
+export function resolveWorkspacePullRequestPlan({ workspaceSyncPhase, forceCursorNull, currentCursor }) {
+    const bootstrap = workspaceSyncPhase === 'attach-cloud';
+    return {
+        bootstrap,
+        cursor: bootstrap || forceCursorNull === true ? null : currentCursor,
+        successEventType: bootstrap ? 'bootstrap' : 'pull'
+    };
+}
+export function resolveWorkspacePullSuccessPlan({ workspaceSyncPhase, forceCursorNull, startupFullReconcileRan, pendingSignature, fallbackSignature, lastPushedSignature }) {
+    const bootstrap = workspaceSyncPhase === 'attach-cloud';
+    const nextSignature = pendingSignature || fallbackSignature;
+    const deferredPushSignature = (!bootstrap
+        && nextSignature
+        && nextSignature !== lastPushedSignature) ? nextSignature : null;
+    return {
+        successEventType: bootstrap ? 'bootstrap' : 'pull',
+        shouldCaptureAttachBootstrapBaseline: bootstrap,
+        shouldClearPendingSignature: bootstrap || deferredPushSignature !== null,
+        shouldRefreshReferenceSnapshots: bootstrap,
+        shouldSeedWorkspaceSnapshotPushBaseline: bootstrap,
+        shouldScheduleStartupFullReconcile: !forceCursorNull && !bootstrap && !startupFullReconcileRan,
+        deferredPushSignature
+    };
+}

package/dist/hooks/sync/pullLifecycle.test.d.ts

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

package/dist/hooks/sync/pullLifecycle.test.js

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+import { resolveWorkspacePullRequestPlan, resolveWorkspacePullSuccessPlan, } from './pullLifecycle';
+describe('pull lifecycle', () => {
+    it('treats attach-cloud pulls as bootstrap pulls with a null cursor', () => {
+        expect(resolveWorkspacePullRequestPlan({
+            workspaceSyncPhase: 'attach-cloud',
+            forceCursorNull: false,
+            currentCursor: 'cursor-1'
+        })).toEqual({
+            bootstrap: true,
+            cursor: null,
+            successEventType: 'bootstrap'
+        });
+    });
+    it('keeps the saved cursor for normal incremental pulls', () => {
+        expect(resolveWorkspacePullRequestPlan({
+            workspaceSyncPhase: 'active',
+            forceCursorNull: false,
+            currentCursor: 'cursor-1'
+        })).toEqual({
+            bootstrap: false,
+            cursor: 'cursor-1',
+            successEventType: 'pull'
+        });
+    });
+    it('marks attach-cloud success for reference refresh and baseline seeding without a follow-up push', () => {
+        expect(resolveWorkspacePullSuccessPlan({
+            workspaceSyncPhase: 'attach-cloud',
+            forceCursorNull: false,
+            startupFullReconcileRan: false,
+            pendingSignature: 'sig-pending',
+            fallbackSignature: 'sig-fallback',
+            lastPushedSignature: ''
+        })).toEqual({
+            successEventType: 'bootstrap',
+            shouldCaptureAttachBootstrapBaseline: true,
+            shouldClearPendingSignature: true,
+            shouldRefreshReferenceSnapshots: true,
+            shouldSeedWorkspaceSnapshotPushBaseline: true,
+            shouldScheduleStartupFullReconcile: false,
+            deferredPushSignature: null
+        });
+    });
+    it('schedules a one-time startup full reconcile and deferred push after the first normal pull', () => {
+        expect(resolveWorkspacePullSuccessPlan({
+            workspaceSyncPhase: 'active',
+            forceCursorNull: false,
+            startupFullReconcileRan: false,
+            pendingSignature: 'sig-pending',
+            fallbackSignature: 'sig-fallback',
+            lastPushedSignature: 'sig-old'
+        })).toEqual({
+            successEventType: 'pull',
+            shouldCaptureAttachBootstrapBaseline: false,
+            shouldClearPendingSignature: true,
+            shouldRefreshReferenceSnapshots: false,
+            shouldSeedWorkspaceSnapshotPushBaseline: false,
+            shouldScheduleStartupFullReconcile: true,
+            deferredPushSignature: 'sig-pending'
+        });
+    });
+    it('does not schedule a second startup full reconcile or redundant deferred push', () => {
+        expect(resolveWorkspacePullSuccessPlan({
+            workspaceSyncPhase: 'active',
+            forceCursorNull: true,
+            startupFullReconcileRan: true,
+            pendingSignature: '',
+            fallbackSignature: 'sig-current',
+            lastPushedSignature: 'sig-current'
+        })).toEqual({
+            successEventType: 'pull',
+            shouldCaptureAttachBootstrapBaseline: false,
+            shouldClearPendingSignature: false,
+            shouldRefreshReferenceSnapshots: false,
+            shouldSeedWorkspaceSnapshotPushBaseline: false,
+            shouldScheduleStartupFullReconcile: false,
+            deferredPushSignature: null
+        });
+    });
+});

package/dist/hooks/sync/recovery.d.ts

@@ -1,8 +1,9 @@
 import type { MutableRefObject } from 'react';
+import type { WorkspaceSyncBaselineResetReason } from '../../sync/workspaceSyncModel';
 import type { WorkspaceSyncPhase } from '../../sync/workspaceSyncState';
+type SyncEventType = 'pull' | 'handshake' | 'bootstrap' | 'apply' | 'push';
 interface CreateSyncRecoveryCoordinatorArgs {
     currentWorkspaceId: string;
-    taxonomyStateFingerprint: string;
     workspaceCloudSyncEnabled: boolean;
     workspaceSyncPhase: WorkspaceSyncPhase;
     workspaceLastPullAt: string | null;
@@ -18,12 +19,14 @@ interface CreateSyncRecoveryCoordinatorArgs {
     workspacePendingSignatureRef: MutableRefObject<string>;
     workspaceLastPushedSignatureRef: MutableRefObject<string>;
     workspaceLastPushedWatermarksRef: MutableRefObject<Map<string, string>>;
+    workspaceLastPushedTaskChangeKeysRef: MutableRefObject<Map<string, string>>;
     workspaceLastPushedInitiativeIdsRef: MutableRefObject<Set<string>>;
     workspaceLastPushedInitiativeWatermarksRef: MutableRefObject<Map<string, string>>;
     workspaceLastPushedWorkstreamIdsRef: MutableRefObject<Set<string>>;
     workspaceLastPushedWorkstreamWatermarksRef: MutableRefObject<Map<string, string>>;
     workspaceLastPushedAiProfileIdsRef: MutableRefObject<Set<string>>;
     workspaceLastPushedAiProfileWatermarksRef: MutableRefObject<Map<string, string>>;
+    workspaceLastPushedAiProfileChangeKeysRef: MutableRefObject<Map<string, string>>;
     workspaceLastPushedDocumentPathsRef: MutableRefObject<Set<string>>;
     workspaceLastPushedDocumentWatermarksRef: MutableRefObject<Map<string, string>>;
     workspaceLastPushedAssetPathsRef: MutableRefObject<Set<string>>;
@@ -35,6 +38,7 @@ interface CreateSyncRecoveryCoordinatorArgs {
     workspaceLastPushedAnnotatedAttachmentSessionIdsRef: MutableRefObject<Set<string>>;
     workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef: MutableRefObject<Map<string, string>>;
     workspaceLastPushedTaskEventWatermarksRef: MutableRefObject<Map<string, string>>;
+    workspaceBaselineResetReasonRef: MutableRefObject<WorkspaceSyncBaselineResetReason | null>;
     bootstrapPhaseStartedAtRef: MutableRefObject<number | null>;
     bootstrapLastProgressAtRef: MutableRefObject<number | null>;
     acquireWorkspaceSyncLease: (workspaceId: string, owner: 'pull' | 'push' | 'repair') => Promise<boolean>;
@@ -43,11 +47,21 @@ interface CreateSyncRecoveryCoordinatorArgs {
     clearWorkspaceRetry: () => void;
     clearWorkspaceIssue: () => void;
     reportWorkspaceWindowContention: (operation: 'pull' | 'push' | 'repair') => void;
+    reportSyncEvent: (workspaceId: string, event: {
+        eventType: SyncEventType;
+        status: 'success' | 'error';
+        statusCode?: number;
+        errorMessage?: string;
+        changeCount?: number;
+        requestMs?: number;
+        details?: Record<string, unknown>;
+    }) => void;
     persistWorkspaceSyncPatch: (patch: {
         phase: WorkspaceSyncPhase;
         pullCursor: null;
         lastErrorMessage: null;
     }) => Promise<unknown>;
+    persistWorkspaceSyncWatermarksSnapshotBestEffort: () => boolean;
     buildWorkspaceSyncSignature: () => string;
     pullWorkspaceChangesFromCloud: (options?: {
         repairMode?: boolean;
@@ -62,7 +76,7 @@ interface CreateSyncRecoveryCoordinatorArgs {
     isAuthenticated: boolean;
     checkAuthSession: () => Promise<boolean>;
 }
-export declare function createSyncRecoveryCoordinator({ currentWorkspaceId, taxonomyStateFingerprint, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceLastPullAt, lastBootstrapPhaseRef, workspaceRepairModeRef, workspaceForceFullAiProfilePushRef, workspaceStartupRepairRanRef, workspaceStartupFullReconcileRanRef, workspaceFullReconcileInFlightRef, workspacePullCursorRef, workspaceAttachBootstrapBaselineSignatureRef, workspaceCaptureAttachBootstrapBaselineRef, workspacePendingSignatureRef, workspaceLastPushedSignatureRef, workspaceLastPushedWatermarksRef, workspaceLastPushedInitiativeIdsRef, workspaceLastPushedInitiativeWatermarksRef, workspaceLastPushedWorkstreamIdsRef, workspaceLastPushedWorkstreamWatermarksRef, workspaceLastPushedAiProfileIdsRef, workspaceLastPushedAiProfileWatermarksRef, workspaceLastPushedDocumentPathsRef, workspaceLastPushedDocumentWatermarksRef, workspaceLastPushedAssetPathsRef, workspaceLastPushedAssetWatermarksRef, workspaceLastPushedDocumentReviewSessionIdsRef, workspaceLastPushedDocumentReviewSessionWatermarksRef, workspaceLastPushedDocumentReviewCommentIdsRef, workspaceLastPushedDocumentReviewCommentWatermarksRef, workspaceLastPushedAnnotatedAttachmentSessionIdsRef, workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, workspaceLastPushedTaskEventWatermarksRef, bootstrapPhaseStartedAtRef, bootstrapLastProgressAtRef, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, forceClearWorkspaceSyncLease, clearWorkspaceRetry, clearWorkspaceIssue, reportWorkspaceWindowContention, persistWorkspaceSyncPatch, buildWorkspaceSyncSignature, pullWorkspaceChangesFromCloud, pushWorkspaceChangesToCloud, cloudAuthConfigured, runtimeMode, isAuthenticated, checkAuthSession }: CreateSyncRecoveryCoordinatorArgs): {
+export declare function createSyncRecoveryCoordinator({ currentWorkspaceId, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceLastPullAt, lastBootstrapPhaseRef, workspaceRepairModeRef, workspaceForceFullAiProfilePushRef, workspaceStartupRepairRanRef, workspaceStartupFullReconcileRanRef, workspaceFullReconcileInFlightRef, workspacePullCursorRef, workspaceAttachBootstrapBaselineSignatureRef, workspaceCaptureAttachBootstrapBaselineRef, workspacePendingSignatureRef, workspaceLastPushedSignatureRef, workspaceLastPushedWatermarksRef, workspaceLastPushedTaskChangeKeysRef, workspaceLastPushedInitiativeIdsRef, workspaceLastPushedInitiativeWatermarksRef, workspaceLastPushedWorkstreamIdsRef, workspaceLastPushedWorkstreamWatermarksRef, workspaceLastPushedAiProfileIdsRef, workspaceLastPushedAiProfileWatermarksRef, workspaceLastPushedAiProfileChangeKeysRef, workspaceLastPushedDocumentPathsRef, workspaceLastPushedDocumentWatermarksRef, workspaceLastPushedAssetPathsRef, workspaceLastPushedAssetWatermarksRef, workspaceLastPushedDocumentReviewSessionIdsRef, workspaceLastPushedDocumentReviewSessionWatermarksRef, workspaceLastPushedDocumentReviewCommentIdsRef, workspaceLastPushedDocumentReviewCommentWatermarksRef, workspaceLastPushedAnnotatedAttachmentSessionIdsRef, workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, workspaceLastPushedTaskEventWatermarksRef, workspaceBaselineResetReasonRef, bootstrapPhaseStartedAtRef, bootstrapLastProgressAtRef, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, forceClearWorkspaceSyncLease, clearWorkspaceRetry, clearWorkspaceIssue, reportWorkspaceWindowContention, reportSyncEvent, persistWorkspaceSyncPatch, persistWorkspaceSyncWatermarksSnapshotBestEffort, buildWorkspaceSyncSignature, pullWorkspaceChangesFromCloud, pushWorkspaceChangesToCloud, cloudAuthConfigured, runtimeMode, isAuthenticated, checkAuthSession }: CreateSyncRecoveryCoordinatorArgs): {
     retryWorkspaceCloudSync: () => Promise<boolean>;
     resetWorkspaceSyncCursorAndPull: () => Promise<void>;
 };