@taskforcehq/taskforce 0.3.305 → 0.3.306

package/dist/hooks/useSyncOrchestrator.retry-closure.test.js

@@ -896,6 +896,114 @@ describe('useSyncOrchestrator', () => {
         ]));
         unmount();
     });
+    it('schedules a delete push when authoritative deleted task state changes', async () => {
+        vi.useFakeTimers();
+        const baseTask = {
+            id: 'task-local-delete-1',
+            title: 'Local delete task',
+            status: 'task',
+            createdAt: '2026-03-14T12:00:00.000Z',
+            updatedAt: '2026-03-14T12:00:00.000Z'
+        };
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T15:05:00.000Z',
+            requestMs: 1,
+            changeCount: 1,
+            deleteCount: 0,
+            currentTaskIds: new Set(['task-local-delete-1']),
+            deleteTaskIds: new Set(),
+            currentDocumentPaths: new Set(),
+            deleteDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            deleteAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            deleteDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            pushedWatermarks: new Map([['task-local-delete-1', '2026-03-14T12:00:00.000Z']]),
+            emittedEventIds: []
+        });
+        let input = buildInput({
+            tasks: [baseTask]
+        });
+        const { result, rerender, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: input
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'provision-local',
+                pullCursor: null
+            });
+        });
+        await act(async () => {
+            await vi.runOnlyPendingTimersAsync();
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        runWorkspacePushSyncServiceMock.mockClear();
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T15:06:00.000Z',
+            requestMs: 1,
+            changeCount: 0,
+            deleteCount: 1,
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(['task-local-delete-1']),
+            currentDocumentPaths: new Set(),
+            deleteDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            deleteAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            deleteDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: []
+        });
+        input = buildInput({
+            tasks: [],
+            deletedTasks: [{
+                    id: 'deleted-task-local-delete-1',
+                    taskId: 'task-local-delete-1',
+                    workspaceId: 'workspace-local-active',
+                    deletedAt: '2026-03-15T15:06:00.000Z',
+                    actor: 'user-1',
+                    actorType: 'human',
+                    source: 'ui',
+                    taskSnapshot: baseTask
+                }]
+        });
+        rerender(input);
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(1600);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+        const pushedChanges = runWorkspacePushSyncServiceMock.mock.calls
+            .map((call) => call?.[0]?.payload?.changes)
+            .filter(Array.isArray);
+        expect(pushedChanges).toEqual(expect.arrayContaining([
+            expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'delete',
+                    taskId: 'task-local-delete-1',
+                    deletedAt: '2026-03-15T15:06:00.000Z'
+                })
+            ])
+        ]));
+        unmount();
+    });
     it('runs a startup full reconcile after the first successful pull when a saved cursor exists', async () => {
         vi.useFakeTimers();
         runWorkspacePullSyncServiceMock.mockResolvedValue({
@@ -931,6 +1039,66 @@ describe('useSyncOrchestrator', () => {
         expect(runWorkspacePullSyncServiceMock.mock.calls.some((call) => call?.[0]?.cursor === null)).toBe(true);
         unmount();
     });
+    it('clears an invalid saved pull cursor and retries from the beginning', async () => {
+        vi.useFakeTimers();
+        runWorkspacePullSyncServiceMock
+            .mockResolvedValueOnce({
+            success: false,
+            kind: 'pull_http',
+            status: 400,
+            errorCode: 'INVALID_SYNC_CURSOR',
+            error: 'Invalid sync cursor.',
+            cursor: 'stale-cursor',
+            pages: 0,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        })
+            .mockResolvedValueOnce({
+            success: true,
+            syncedAt: '2026-03-15T19:31:00.000Z',
+            cursor: 'fresh-cursor-1',
+            pages: 1,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput()
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: 'stale-cursor'
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(500);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        await act(async () => {
+            await vi.runOnlyPendingTimersAsync();
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(2);
+        expect(runWorkspacePullSyncServiceMock.mock.calls[0]?.[0]?.cursor).toBe('stale-cursor');
+        expect(runWorkspacePullSyncServiceMock.mock.calls.some((call) => call?.[0]?.cursor === null)).toBe(true);
+        expect(result.current.workspaceRetryAt).toBeNull();
+        expect(result.current.workspaceLastErrorMessage).toBeNull();
+        expect(result.current.workspaceSyncPhase).toBe('active');
+        unmount();
+    });
     it('finishes provision-local bootstrap by moving to active after the first push', async () => {
         runWorkspacePushSyncServiceMock.mockResolvedValue({
             success: true,
@@ -1000,6 +1168,243 @@ describe('useSyncOrchestrator', () => {
             expect(result.current.workspaceSyncPhase).toBe('active');
             expect(result.current.workspaceLastPullAt).toBe('2026-03-15T19:00:00.000Z');
         });
+        const persisted = localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active');
+        expect(persisted).toBeTruthy();
+        expect(JSON.parse(String(persisted))).toEqual(expect.objectContaining({
+            v: 11,
+            taskIds: [],
+            taxonomyStateFingerprint: expect.any(String),
+            documentWatermarks: [],
+            assetWatermarks: [],
+            taskEventWatermarks: []
+        }));
+        unmount();
+    });
+    it('persists task and planning baselines when attach-cloud bootstrap completes', async () => {
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-15T19:00:00.000Z',
+            cursor: null,
+            pages: 1,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({
+                tasks: [{
+                        id: 'task-1',
+                        title: 'Seeded task',
+                        status: 'task',
+                        createdAt: '2026-03-15T18:00:00.000Z',
+                        updatedAt: '2026-03-15T18:05:00.000Z'
+                    }],
+                initiatives: [{
+                        id: 'initiative-1',
+                        title: 'Seeded initiative',
+                        createdAt: '2026-03-15T17:00:00.000Z',
+                        updatedAt: '2026-03-15T17:05:00.000Z',
+                        isArchived: false
+                    }],
+                workstreams: [{
+                        id: 'workstream-1',
+                        title: 'Seeded workstream',
+                        initiativeId: 'initiative-1',
+                        createdAt: '2026-03-15T17:10:00.000Z',
+                        updatedAt: '2026-03-15T17:15:00.000Z',
+                        isArchived: false
+                    }]
+            })
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'attach-cloud',
+                pullCursor: null
+            });
+        });
+        await waitFor(() => {
+            expect(result.current.workspaceSyncPhase).toBe('active');
+        });
+        const persisted = JSON.parse(String(localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active')));
+        expect(persisted.taskIds).toEqual(['task-1']);
+        expect(persisted.taskWatermarks).toEqual([['task-1', '2026-03-15T18:05:00.000Z']]);
+        expect(persisted.initiativeWatermarks).toEqual([['initiative-1', '2026-03-15T17:05:00.000Z']]);
+        expect(persisted.workstreamWatermarks).toEqual([['workstream-1', '2026-03-15T17:15:00.000Z']]);
+        unmount();
+    });
+    it('rehydrates push baselines from workspace sync state when local storage is empty', async () => {
+        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: null,
+                            pushBaseline: {
+                                taskIds: ['task-1'],
+                                taskWatermarks: [['task-1', '2026-03-15T18:05:00.000Z']],
+                                initiativeWatermarks: [['initiative-1', '2026-03-15T17:05:00.000Z']],
+                                workstreamWatermarks: [['workstream-1', '2026-03-15T17:15:00.000Z']],
+                                aiProfileWatermarks: [['ai-profile-codex', '2026-03-15T18:00:00.000Z']],
+                                documentWatermarks: [],
+                                assetWatermarks: [],
+                                documentReviewSessionWatermarks: [],
+                                documentReviewCommentWatermarks: [],
+                                annotatedAttachmentSessionWatermarks: [],
+                                taskEventWatermarks: [],
+                                taxonomyStateFingerprint: 'null'
+                            }
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        }));
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({
+                tasks: [{
+                        id: 'task-1',
+                        title: 'Seeded task',
+                        status: 'task',
+                        createdAt: '2026-03-15T18:00:00.000Z',
+                        updatedAt: '2026-03-15T18:05:00.000Z'
+                    }]
+            })
+        });
+        expect(localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active')).toBeNull();
+        await act(async () => {
+            await result.current.loadWorkspaceSyncState();
+        });
+        await waitFor(() => {
+            const persisted = JSON.parse(String(localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active')));
+            expect(persisted.taskIds).toEqual(['task-1']);
+            expect(persisted.taskWatermarks).toEqual([['task-1', '2026-03-15T18:05:00.000Z']]);
+            expect(persisted.initiativeWatermarks).toEqual([['initiative-1', '2026-03-15T17:05:00.000Z']]);
+            expect(persisted.workstreamWatermarks).toEqual([['workstream-1', '2026-03-15T17:15:00.000Z']]);
+            expect(persisted.aiProfileWatermarks).toEqual([['ai-profile-codex', '2026-03-15T18:00:00.000Z']]);
+        });
+        unmount();
+    });
+    it('rehydrates task delete baselines from persisted taskIds even when task watermarks are empty', async () => {
+        vi.useFakeTimers();
+        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: null,
+                            pushBaseline: {
+                                taskIds: ['task-delete-hydrated-1'],
+                                taskWatermarks: [],
+                                initiativeWatermarks: [],
+                                workstreamWatermarks: [],
+                                aiProfileWatermarks: [],
+                                documentWatermarks: [],
+                                assetWatermarks: [],
+                                documentReviewSessionWatermarks: [],
+                                documentReviewCommentWatermarks: [],
+                                annotatedAttachmentSessionWatermarks: [],
+                                taskEventWatermarks: [],
+                                taxonomyStateFingerprint: 'fingerprint-a'
+                            }
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        }));
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: '2026-03-16T12:00:00.000Z',
+            requestMs: 1,
+            changeCount: 0,
+            deleteCount: 1,
+            currentTaskIds: new Set(),
+            deleteTaskIds: new Set(['task-delete-hydrated-1']),
+            currentDocumentPaths: new Set(),
+            deleteDocumentPaths: new Set(),
+            currentDocumentWatermarks: new Map(),
+            currentAssetPaths: new Set(),
+            deleteAssetPaths: new Set(),
+            currentAssetWatermarks: new Map(),
+            currentDocumentReviewSessionIds: new Set(),
+            deleteDocumentReviewSessionIds: new Set(),
+            currentDocumentReviewSessionWatermarks: new Map(),
+            currentAnnotatedAttachmentSessionIds: new Set(),
+            deleteAnnotatedAttachmentSessionIds: new Set(),
+            currentAnnotatedAttachmentSessionWatermarks: new Map(),
+            pushedWatermarks: new Map(),
+            emittedEventIds: []
+        });
+        const { result, unmount } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput({
+                tasks: [],
+                deletedTasks: [{
+                        id: 'deleted-task-delete-hydrated-1',
+                        taskId: 'task-delete-hydrated-1',
+                        workspaceId: 'workspace-local-active',
+                        deletedAt: '2026-03-16T11:59:00.000Z',
+                        actor: 'user-1',
+                        actorType: 'human',
+                        source: 'ui',
+                        taskSnapshot: {
+                            id: 'task-delete-hydrated-1',
+                            title: 'Deleted before reload',
+                            status: 'task',
+                            createdAt: '2026-03-15T10:00:00.000Z',
+                            updatedAt: '2026-03-15T10:00:00.000Z'
+                        }
+                    }]
+            })
+        });
+        await act(async () => {
+            await result.current.loadWorkspaceSyncState();
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                enabled: true,
+                phase: 'active',
+                pullCursor: null
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(1600);
+            await Promise.resolve();
+            await Promise.resolve();
+        });
+        expect(runWorkspacePushSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+        const pushedChanges = runWorkspacePushSyncServiceMock.mock.calls
+            .map((call) => call?.[0]?.payload?.changes)
+            .filter(Array.isArray);
+        expect(pushedChanges).toEqual(expect.arrayContaining([
+            expect.arrayContaining([
+                expect.objectContaining({
+                    op: 'delete',
+                    taskId: 'task-delete-hydrated-1',
+                    deletedAt: '2026-03-16T11:59:00.000Z'
+                })
+            ])
+        ]));
         unmount();
     });
     it('finishes attach-cloud bootstrap locally even if persisting the active phase fails', async () => {
@@ -1614,6 +2019,8 @@ describe('useSyncOrchestrator', () => {
                 ])
             })
         ]));
+        const persisted = JSON.parse(String(localStorage.getItem('taskforce.syncWatermarks.v3.workspace-local-active')));
+        expect(persisted.aiProfileWatermarks).toEqual([['ai-profile-codex', '2026-03-15T18:00:00.000Z']]);
         expect(result.current.workspaceSyncPendingChanges).toBe(0);
         unmount();
     });

package/dist/hooks/useTaskData.js

@@ -102,8 +102,14 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
         const ignoreAuthGuard = options?.ignoreAuthGuard === true;
         if (!ignoreAuthGuard && (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls))
             return;
-        if (!isSilent)
+        if (!isSilent) {
             setLoadingTasks(true);
+        }
+        else {
+            // Silent refreshes should not leave the board-level loading indicator active
+            // if they supersede a visible fetch that already turned it on.
+            setLoadingTasks(false);
+        }
         const requestWorkspaceId = String(getCurrentWorkspaceId() || '').trim();
         tasksAbortRef.current?.abort('superseded');
         const abortController = new AbortController();
@@ -155,9 +161,8 @@ export function useTaskData({ tasks, archivedTasks, setTasks, setArchivedTasks,
             const isCurrentRequest = tasksAbortRef.current === abortController;
             if (isCurrentRequest) {
                 tasksAbortRef.current = null;
-            }
-            if (!isSilent && isCurrentRequest)
                 setLoadingTasks(false);
+            }
         }
     }, [
         getTaskRevisionKey,

package/dist/hooks/useTaskData.test.js

@@ -243,4 +243,49 @@ describe('useTaskData', () => {
         expect(setLoadingTasks).toHaveBeenLastCalledWith(false);
         expect(setLoadingTasks).toHaveBeenCalledTimes(3);
     });
+    it('clears loading when a silent tasks refresh replaces a visible fetch', async () => {
+        const firstRequest = makeControlledAbortableRequest({ tasks: [] });
+        const secondRequest = makeControlledAbortableRequest({ tasks: [] });
+        const fetchMock = vi.mocked(fetch);
+        const setLoadingTasks = vi.fn();
+        let requestCount = 0;
+        fetchMock.mockImplementation((_input, init) => {
+            const signal = init?.signal;
+            requestCount += 1;
+            if (requestCount === 1) {
+                firstRequest.attach(signal);
+                return firstRequest.promise;
+            }
+            secondRequest.attach(signal);
+            return secondRequest.promise;
+        });
+        const { result } = renderHook(() => useTaskData({
+            tasks: [],
+            archivedTasks: [],
+            setTasks: vi.fn(),
+            setArchivedTasks: vi.fn(),
+            setLoadingTasks,
+            getCurrentWorkspaceId: () => 'workspace-1',
+            workspaceResetKey: 'workspace-1',
+            shouldDeferProtectedApiCalls: false,
+            shouldBlockProtectedApiCalls: false,
+            handleUnauthorized: vi.fn(),
+            authRequiredForApi: false
+        }));
+        let firstPromise;
+        let secondPromise;
+        await act(async () => {
+            firstPromise = result.current.fetchTasks(false);
+            secondPromise = result.current.fetchTasks(true);
+            await Promise.resolve();
+        });
+        expect(setLoadingTasks).toHaveBeenNthCalledWith(1, true);
+        expect(setLoadingTasks).toHaveBeenNthCalledWith(2, false);
+        await act(async () => {
+            secondRequest.resolve();
+            await secondPromise;
+            await firstPromise;
+        });
+        expect(setLoadingTasks).toHaveBeenLastCalledWith(false);
+    });
 });

package/dist/hooks/useTaskforce.d.ts

@@ -1,4 +1,4 @@
-import type { TaskforceConfig, TaskforceTheme, Comment, AttachmentItem, CategoryConfig, TaskItem, TaxonomyDefinition, Environment, TaskAssignee, TaskStatus, DeletedTaskRecord, InitiativeItem, WorkstreamItem, ChecklistItem } from '../types';
+import type { TaskforceConfig, TaskforceTheme, Comment, AttachmentItem, CategoryConfig, TaskItem, TaxonomyDefinition, Environment, TaskAssignee, TaskStatus, DeletedTaskRecord, InitiativeItem, WorkstreamItem, ChecklistItem, PlanningBootstrapWorkstreamTaskSummary } from '../types';
 import { type FirstClassTaxonomyDisplayLabels } from '../shared/taxonomyState.js';
 import type { UiNotice } from '../utils/uiNotice';
 import type { TaskAssigneeOption } from '../utils/assignees';
@@ -37,6 +37,27 @@ interface RuntimeCapabilities {
     supportsAdminManagedSetupOverrides: boolean;
     supportsPackageScriptSetupOverrides: boolean;
 }
+interface BootstrapStateSnapshot {
+    phase: BootstrapPhase;
+    auth: {
+        resolved: boolean;
+        pending: boolean;
+    };
+    config: {
+        loaded: boolean;
+    };
+    workspace: {
+        pending: boolean;
+    };
+    pending: boolean;
+    authPending: boolean;
+    appPending: boolean;
+    ready: boolean;
+    stalled: boolean;
+    subtitle: string;
+    error: string | null;
+    startedAt: number | null;
+}
 interface WorkspaceSummary {
     id: string;
     slug?: string | null;
@@ -122,7 +143,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     authUserDisplayName: string;
     authUserAvatarUrl: string;
     authWorkspaceId: string;
-    userGlobalSyncStatus: "error" | "idle" | "disconnected" | "syncing";
+    userGlobalSyncStatus: "error" | "idle" | "syncing" | "disconnected";
     workspaceLastPullAt: string | null;
     workspaceLastPushAt: string | null;
     workspaceLastErrorAt: string | null;
@@ -152,6 +173,13 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         pendingChanges: number;
         lastErrorMessage: string | null;
         recommendedAction: string;
+        pushBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        pullBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        retryBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        repairActive: boolean;
+        pushInFlight: boolean;
+        pullInFlight: boolean;
+        retryPending: boolean;
         documentSnapshotCount: number;
         aiProfileSnapshotCount: number;
         aiProfileSnapshotRawCount: number;
@@ -185,6 +213,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         enabled: boolean;
         phase?: import("../sync/workspaceSyncState").WorkspaceSyncPhase | null;
     }) => void>[0]) => void;
+    bootstrapState: BootstrapStateSnapshot;
     authSessionResolved: boolean;
     workspaceBootstrapPending: boolean;
     bootstrapPhase: BootstrapPhase;
@@ -242,6 +271,31 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         code?: string;
         workspaceSetupRequired?: boolean;
     }>;
+    beginOAuthLogin: (provider: string, returnTo?: string, inviteToken?: string) => void;
+    availableAuthProviders: string[];
+    fetchLoginMethods: () => Promise<{
+        success: boolean;
+        error?: string;
+        methods?: Array<{
+            provider: string;
+            providerEmail: string | null;
+            displayNameSnapshot: string | null;
+            avatarUrlSnapshot: string | null;
+            linkedAt: string | null;
+            lastLoginAt: string | null;
+        }>;
+    }>;
+    unlinkLoginMethod: (provider: string) => Promise<{
+        success: boolean;
+        error?: string;
+        code?: string;
+    }>;
+    addPasswordToAccount: (password: string) => Promise<{
+        success: boolean;
+        error?: string;
+        code?: string;
+    }>;
+    beginOAuthLink: (provider: string, returnTo?: string) => void;
     registerWithCredentials: (email: string, password: string, options?: {
         displayName?: string | null;
         planId?: string | null;
@@ -312,6 +366,8 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         workspaceId?: string;
         inviteeKind?: "existing_user" | "new_user";
         passwordRequired?: boolean;
+        inviteeState?: "pending_setup" | "existing_account";
+        availableMethods?: string[];
     }>;
     acceptInviteWithToken: (token: string, password: string) => Promise<{
         success: boolean;
@@ -356,6 +412,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     archivedTasks: TaskItem[];
     initiatives: InitiativeItem[];
     workstreams: WorkstreamItem[];
+    planningBootstrapTaskSummaries: PlanningBootstrapWorkstreamTaskSummary[];
     deletedTasks: DeletedTaskRecord[];
     activeCategories: CategoryConfig[];
     activeTypes: {
@@ -394,6 +451,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     setFilterAssignees: (nextValues: TaskAssignee[] | ((prev: TaskAssignee[]) => TaskAssignee[])) => void;
     filterTaxonomies: Record<string, (string | number)[]>;
     setFilterTaxonomies: import("react").Dispatch<import("react").SetStateAction<Record<string, (string | number)[]>>>;
+    hasInitedFilters: boolean;
     sortBy: import("../utils/taxonomySorting").TaskSortKey;
     setSortBy: import("react").Dispatch<import("react").SetStateAction<import("../utils/taxonomySorting").TaskSortKey>>;
     sortOrder: "asc" | "desc";