@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/hooks/useWorkspaceSyncController.d.ts

@@ -39,6 +39,7 @@ export declare function useWorkspaceSyncController(input: UseWorkspaceSyncContro
     }) => void;
     persistWorkspaceSyncPatch: (patch: Partial<WorkspaceSyncStateV2>) => Promise<WorkspaceSyncStateV2>;
     applyWorkspaceSyncPatchLocally: (patch: Partial<WorkspaceSyncStateV2>) => WorkspaceSyncStateV2;
+    readWorkspaceSyncStateSnapshot: () => WorkspaceSyncStateV2;
     loadWorkspaceSyncState: () => Promise<void>;
     applyWorkspaceSyncStateSnapshot: (nextState: Partial<WorkspaceSyncStateV2> & {
         enabled: boolean;

package/dist/hooks/useWorkspaceSyncController.js

@@ -64,7 +64,8 @@ function buildWorkspaceSyncStatePatch(current, patch) {
         lastPullAt: patch.lastPullAt === undefined ? current.lastPullAt : normalizeCursor(patch.lastPullAt),
         lastPushAt: patch.lastPushAt === undefined ? current.lastPushAt : normalizeCursor(patch.lastPushAt),
         lastSyncedAt: patch.lastSyncedAt === undefined ? current.lastSyncedAt : normalizeCursor(patch.lastSyncedAt),
-        lastErrorMessage: patch.lastErrorMessage === undefined ? current.lastErrorMessage : (patch.lastErrorMessage ?? null)
+        lastErrorMessage: patch.lastErrorMessage === undefined ? current.lastErrorMessage : (patch.lastErrorMessage ?? null),
+        pushBaseline: patch.pushBaseline === undefined ? (current.pushBaseline ?? null) : (patch.pushBaseline ?? null)
     };
     if (!next.enabled) {
         next.phase = 'idle';
@@ -73,6 +74,12 @@ function buildWorkspaceSyncStatePatch(current, patch) {
     }
     return next;
 }
+function buildRemoteWorkspaceSyncStatePatch(state) {
+    return {
+        ...state,
+        pushBaseline: null
+    };
+}
 export function useWorkspaceSyncController(input) {
     const { currentWorkspaceId, setWorkspaceCloudSyncEnabled, setWorkspaceSyncPhase, setWorkspaceSyncSetupIntent, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceLastErrorMessage } = input;
     const [workspaceRetryAt, setWorkspaceRetryAt] = useState(null);
@@ -286,6 +293,9 @@ export function useWorkspaceSyncController(input) {
         applyWorkspaceSyncStateSnapshot(next);
         return next;
     }, [applyWorkspaceSyncStateSnapshot]);
+    const readWorkspaceSyncStateSnapshot = useCallback(() => {
+        return workspaceSyncStateRef.current;
+    }, []);
     const persistWorkspaceSyncPatch = useCallback(async (patch) => {
         const next = buildWorkspaceSyncStatePatch(workspaceSyncStateRef.current, patch);
         workspaceSyncStateRef.current = next;
@@ -293,7 +303,7 @@ export function useWorkspaceSyncController(input) {
         const result = await persistRemoteUiState({
             workspaceId: currentWorkspaceId,
             stateKey: 'workspace-sync',
-            patch: next,
+            patch: buildRemoteWorkspaceSyncStatePatch(next),
             throwOnError: true,
             respectFailureCooldown: false
         });
@@ -428,6 +438,7 @@ export function useWorkspaceSyncController(input) {
         scheduleWorkspaceRetry,
         persistWorkspaceSyncPatch,
         applyWorkspaceSyncPatchLocally,
+        readWorkspaceSyncStateSnapshot,
         loadWorkspaceSyncState,
         applyWorkspaceSyncStateSnapshot,
         saveWorkspaceCloudSyncSettings,

package/dist/hooks/useWorkspaceSyncController.test.js

@@ -89,6 +89,54 @@ describe('useWorkspaceSyncController', () => {
         expect(input.setWorkspaceCloudSyncEnabled).toHaveBeenCalledWith(true);
         expect(input.setWorkspaceSyncPhase).toHaveBeenCalledWith('attach-cloud');
     });
+    it('clears local-only push baselines from remote ui-state patches', async () => {
+        const uiStatePosts = [];
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            version: 2,
+                            enabled: true,
+                            phase: 'active',
+                            pullCursor: 'cursor-1',
+                            pushBaseline: {
+                                taskIds: ['task-1'],
+                                taskWatermarks: [['task-1', 'x'.repeat(1024 * 1024)]],
+                                initiativeWatermarks: [],
+                                workstreamWatermarks: [],
+                                aiProfileWatermarks: [],
+                                documentWatermarks: [],
+                                assetWatermarks: [],
+                                documentReviewSessionWatermarks: [],
+                                documentReviewCommentWatermarks: [],
+                                annotatedAttachmentSessionWatermarks: [],
+                                taskEventWatermarks: [],
+                                taxonomyStateFingerprint: ''
+                            }
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                uiStatePosts.push(JSON.parse(String(init?.body || '{}')));
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        }));
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        await act(async () => {
+            await result.current.loadWorkspaceSyncState();
+            await result.current.persistWorkspaceSyncPatch({ lastPullAt: '2026-04-27T20:30:00.000Z' });
+        });
+        expect(result.current.readWorkspaceSyncStateSnapshot().pushBaseline?.taskWatermarks[0]?.[1]).toHaveLength(1024 * 1024);
+        expect(uiStatePosts).toHaveLength(1);
+        expect(uiStatePosts[0]?.patch?.lastPullAt).toBe('2026-04-27T20:30:00.000Z');
+        expect(uiStatePosts[0]?.patch?.pushBaseline).toBeNull();
+        expect(JSON.stringify(uiStatePosts[0])).not.toContain('xxxx');
+    });
     it('persists attach-cloud phase when enabling sync for an existing cloud workspace', async () => {
         const uiStatePosts = [];
         vi.stubGlobal('fetch', vi.fn((url, init) => {

package/dist/hooks/workspace/useTaskforceWorkspaceBootstrap.d.ts

@@ -11,6 +11,14 @@ export interface WorkspaceSummary {
     status?: string;
     betaAccess?: boolean;
 }
+type CloudBootstrapReason = 'initial-load' | 'post-plans' | 'retry';
+type CloudBootstrapResult = {
+    success: boolean;
+    authenticated: boolean;
+    workspaceSetupRequired: boolean;
+    error?: string;
+    code?: string;
+};
 interface UseTaskforceWorkspaceBootstrapArgs {
     shouldDeferProtectedApiCalls: boolean;
     shouldBlockProtectedApiCalls: boolean;
@@ -67,6 +75,7 @@ interface UseTaskforceWorkspaceBootstrapArgs {
     authSessionResolved: boolean;
     isAuthenticated: boolean;
     authUserId: string;
+    authUserAvatarUrl: string;
     setHydratedWorkspaceRole: (value: WorkspaceRole | null) => void;
     setAssigneeOptions: (value: TaskAssigneeOption[]) => void;
     setAssigneeOptionsLoaded: (value: boolean) => void;
@@ -90,6 +99,7 @@ interface UseTaskforceWorkspaceBootstrapArgs {
     showArchive: boolean;
     taskScope: string;
     settingsSection: string | null;
+    workspaceBootstrapPending: boolean;
     fetchTasks: (isSilent?: boolean, options?: {
         ignoreAuthGuard?: boolean;
     }) => Promise<void>;
@@ -162,5 +172,11 @@ export declare function useTaskforceWorkspaceBootstrap(args: UseTaskforceWorkspa
         workspaceId?: undefined;
     }>;
     retryBootstrapChecks: () => Promise<void>;
+    runCloudBootstrap: (options?: {
+        reason?: CloudBootstrapReason;
+        ignoreAuthGuard?: boolean;
+        tasksSilent?: boolean;
+        includeDeferredArchive?: boolean;
+    }) => Promise<CloudBootstrapResult>;
 };
 export {};