@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/hooks/useTaskforce.sync-behavior.test.js

@@ -186,8 +186,49 @@ describe('useTaskforce sync behavior', () => {
             expect(childTask?.status).toBe('in-progress');
         });
     });
-    it('keeps the dawn theme when settings re-fetch configuration', async () => {
-        const fetchMock = vi.fn((url) => {
+    it('keeps a created workstream visible even if the follow-up planning refresh is stale', async () => {
+        const initialInitiative = {
+            id: 'initiative-1',
+            title: 'AI & MCP',
+            description: 'Planning initiative',
+            ownerId: null,
+            createdAt: '2026-03-15T10:00:00.000Z',
+            updatedAt: '2026-03-15T10:00:00.000Z',
+            referenceNumber: 5,
+            referenceLabel: 'IN-5',
+            isArchived: false,
+            comments: [],
+            attachments: []
+        };
+        const initialWorkstream = {
+            id: 'workstream-1',
+            title: 'MCP Tools',
+            description: 'Existing workstream',
+            ownerId: null,
+            initiativeId: 'initiative-1',
+            createdAt: '2026-03-15T10:05:00.000Z',
+            updatedAt: '2026-03-15T10:05:00.000Z',
+            referenceNumber: 640,
+            referenceLabel: 'WS-640',
+            isArchived: false,
+            comments: [],
+            attachments: []
+        };
+        const createdWorkstream = {
+            id: 'workstream-2',
+            title: 'Agent Manager',
+            description: 'New workstream',
+            ownerId: null,
+            initiativeId: 'initiative-1',
+            createdAt: '2026-03-15T10:10:00.000Z',
+            updatedAt: '2026-03-15T10:10:00.000Z',
+            referenceNumber: 641,
+            referenceLabel: 'WS-641',
+            isArchived: false,
+            comments: [],
+            attachments: []
+        };
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
                 return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
@@ -212,9 +253,6 @@ describe('useTaskforce sync behavior', () => {
             }
             if (url.includes('/api/taskforce/config')) {
                 return jsonResponse({
-                    theme: 'dawn',
-                    globalTheme: 'dawn',
-                    themeUseGlobalDefault: true,
                     projectName: 'Test Project',
                     workspaceId: 'workspace-local-active',
                     runtimeMode: 'local',
@@ -241,38 +279,78 @@ describe('useTaskforce sync behavior', () => {
                 return jsonResponse({ tasks: [activeTask] });
             if (url.includes('/api/taskforce/archive'))
                 return jsonResponse({ archived: [] });
-            if (url.includes('/api/taskforce/data-version'))
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                return jsonResponse({
+                    initiatives: [initialInitiative],
+                    workstreams: [initialWorkstream],
+                    workstreamTaskSummaries: [{
+                            workstreamId: initialWorkstream.id,
+                            taskCount: 1,
+                            completedTaskCount: 0,
+                            tasks: [{
+                                    id: activeTask.id,
+                                    title: activeTask.title,
+                                    status: activeTask.status,
+                                }],
+                        }],
+                });
+            }
+            if (url.includes('/api/taskforce/workstream') && String(init?.method || '').toUpperCase() === 'POST') {
+                return jsonResponse(createdWorkstream, 201);
+            }
+            if (url.includes('/api/taskforce/data-version')) {
                 return jsonResponse({ dataVersion: 1 });
+            }
             return jsonResponse({});
-        });
-        vi.stubGlobal('fetch', fetchMock);
+        }));
         const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
         await waitFor(() => {
-            expect(result.current.currentTheme).toBe('dawn');
+            expect(result.current.tasks.some((task) => task.id === activeTask.id)).toBe(true);
         });
         await act(async () => {
-            result.current.setIsOpen(true);
-            result.current.setActiveTab('settings');
+            await result.current.createWorkstream({
+                title: createdWorkstream.title,
+                description: createdWorkstream.description,
+                initiativeId: createdWorkstream.initiativeId
+            });
         });
         await waitFor(() => {
-            expect(fetchMock.mock.calls.filter(([url]) => String(url).includes('/api/taskforce/config'))).toHaveLength(2);
-            expect(result.current.currentTheme).toBe('dawn');
+            expect(result.current.workstreams.some((workstream) => workstream.id === createdWorkstream.id)).toBe(true);
         });
     });
-    it('merges a server-returned archived task immediately instead of dropping it between collections', async () => {
-        vi.stubGlobal('fetch', vi.fn((url, init) => {
+    it('falls back to legacy planning endpoints when bootstrap is unavailable during startup', async () => {
+        const initiative = {
+            id: 'initiative-fallback-1',
+            title: 'Fallback initiative',
+            description: null,
+            createdAt: '2026-03-15T10:00:00.000Z',
+        };
+        const workstream = {
+            id: 'workstream-fallback-1',
+            title: 'Fallback workstream',
+            description: null,
+            initiativeId: initiative.id,
+            createdAt: '2026-03-15T10:05:00.000Z',
+        };
+        vi.stubGlobal('fetch', vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
                 return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
-            if (url.includes('/api/taskforce/ui-state?key=app')) {
-                return jsonResponse({ success: true, state: {} });
-            }
-            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+            if (url.includes('/api/taskforce/auth/session')) {
                 return jsonResponse({
-                    success: true,
-                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                    authenticated: false,
+                    authRequiredForApi: false,
+                    betaAccess: true,
+                    userId: 'anonymous',
+                    email: '',
+                    workspaceId: 'workspace-local-active'
                 });
             }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({ success: true, state: { version: 2, enabled: false, phase: 'idle', pullCursor: null } });
+            }
             if (url.includes('/api/taskforce/config')) {
                 return jsonResponse({
                     projectName: 'Test Project',
@@ -285,72 +363,75 @@ describe('useTaskforce sync behavior', () => {
                     }
                 });
             }
-            if (url.includes('/api/taskforce/global-settings')) {
+            if (url.includes('/api/taskforce/global-settings'))
                 return jsonResponse({});
-            }
-            if (url.includes('/api/taskforce/categories')) {
+            if (url.includes('/api/taskforce/categories'))
                 return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
-            }
-            if (url.includes('/api/taskforce/types')) {
+            if (url.includes('/api/taskforce/types'))
                 return jsonResponse({ types: [] });
-            }
-            if (url.includes('/api/taskforce/priorities')) {
+            if (url.includes('/api/taskforce/priorities'))
                 return jsonResponse({ priorities: [] });
-            }
-            if (url.includes('/api/taskforce/approaches')) {
+            if (url.includes('/api/taskforce/approaches'))
                 return jsonResponse({ approaches: [] });
-            }
-            if (url.includes('/api/taskforce/specialists')) {
+            if (url.includes('/api/taskforce/specialists'))
                 return jsonResponse({ specialists: [] });
-            }
-            if (url.includes('/api/taskforce/tasks')) {
+            if (url.includes('/api/taskforce/tasks'))
                 return jsonResponse({ tasks: [activeTask] });
-            }
-            if (url.includes('/api/taskforce/archive')) {
+            if (url.includes('/api/taskforce/archive'))
                 return jsonResponse({ archived: [] });
-            }
-            if (url.includes('/api/taskforce/task/task-parent/complete') && String(init?.method || '').toUpperCase() === 'POST') {
-                return jsonResponse({
-                    ...activeTask,
-                    status: 'done',
-                    isArchived: true,
-                    completedAt: '2026-03-15T10:20:00.000Z',
-                    updatedAt: '2026-03-15T10:20:00.000Z'
-                });
-            }
-            if (url.includes('/api/taskforce/data-version')) {
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ error: 'missing' }, 404);
+            if (url.includes('/api/taskforce/initiatives'))
+                return jsonResponse([initiative]);
+            if (url.includes('/api/taskforce/workstreams'))
+                return jsonResponse([workstream]);
+            if (url.includes('/api/taskforce/data-version'))
                 return jsonResponse({ dataVersion: 1 });
-            }
             return jsonResponse({});
         }));
         const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
         await waitFor(() => {
-            expect(result.current.tasks.some((task) => task.id === 'task-parent')).toBe(true);
-        });
-        await act(async () => {
-            await result.current.handleArchiveTask(activeTask);
+            expect(result.current.tasks.some((task) => task.id === activeTask.id)).toBe(true);
         });
         await waitFor(() => {
-            expect(result.current.tasks.some((task) => task.id === 'task-parent')).toBe(false);
-            const archived = result.current.archivedTasks.find((task) => task.id === 'task-parent');
-            expect(archived?.isArchived).toBe(true);
-            expect(archived?.status).toBe('done');
-        });
+            expect(result.current.initiatives.some((item) => item.id === initiative.id)).toBe(true);
+            expect(result.current.workstreams.some((item) => item.id === workstream.id)).toBe(true);
+        }, { timeout: 3000 });
     });
-    it('merges a server-returned completed task immediately when toggling done', async () => {
-        vi.stubGlobal('fetch', vi.fn((url, init) => {
+    it('retries planning bootstrap after a transient startup failure', async () => {
+        const initiative = {
+            id: 'initiative-retry-1',
+            title: 'Retry initiative',
+            description: null,
+            createdAt: '2026-03-15T10:00:00.000Z',
+        };
+        const workstream = {
+            id: 'workstream-retry-1',
+            title: 'Retry workstream',
+            description: null,
+            initiativeId: initiative.id,
+            createdAt: '2026-03-15T10:05:00.000Z',
+        };
+        let planningBootstrapCalls = 0;
+        vi.stubGlobal('fetch', vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
                 return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
-            if (url.includes('/api/taskforce/ui-state?key=app')) {
-                return jsonResponse({ success: true, state: {} });
-            }
-            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+            if (url.includes('/api/taskforce/auth/session')) {
                 return jsonResponse({
-                    success: true,
-                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                    authenticated: false,
+                    authRequiredForApi: false,
+                    betaAccess: true,
+                    userId: 'anonymous',
+                    email: '',
+                    workspaceId: 'workspace-local-active'
                 });
             }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({ success: true, state: { version: 2, enabled: false, phase: 'idle', pullCursor: null } });
+            }
             if (url.includes('/api/taskforce/config')) {
                 return jsonResponse({
                     projectName: 'Test Project',
@@ -363,65 +444,74 @@ describe('useTaskforce sync behavior', () => {
                     }
                 });
             }
-            if (url.includes('/api/taskforce/global-settings')) {
+            if (url.includes('/api/taskforce/global-settings'))
                 return jsonResponse({});
-            }
-            if (url.includes('/api/taskforce/categories')) {
+            if (url.includes('/api/taskforce/categories'))
                 return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
-            }
-            if (url.includes('/api/taskforce/types')) {
+            if (url.includes('/api/taskforce/types'))
                 return jsonResponse({ types: [] });
-            }
-            if (url.includes('/api/taskforce/priorities')) {
+            if (url.includes('/api/taskforce/priorities'))
                 return jsonResponse({ priorities: [] });
-            }
-            if (url.includes('/api/taskforce/approaches')) {
+            if (url.includes('/api/taskforce/approaches'))
                 return jsonResponse({ approaches: [] });
-            }
-            if (url.includes('/api/taskforce/specialists')) {
+            if (url.includes('/api/taskforce/specialists'))
                 return jsonResponse({ specialists: [] });
-            }
-            if (url.includes('/api/taskforce/tasks')) {
+            if (url.includes('/api/taskforce/tasks'))
                 return jsonResponse({ tasks: [activeTask] });
-            }
-            if (url.includes('/api/taskforce/archive')) {
+            if (url.includes('/api/taskforce/archive'))
                 return jsonResponse({ archived: [] });
-            }
-            if (url.includes('/api/taskforce/task/task-parent') && String(init?.method || '').toUpperCase() === 'PATCH') {
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                planningBootstrapCalls += 1;
+                if (planningBootstrapCalls === 1) {
+                    return Promise.reject(new Error('temporary failure'));
+                }
                 return jsonResponse({
-                    ...activeTask,
-                    status: 'done',
-                    completedAt: '2026-03-15T10:25:00.000Z',
-                    updatedAt: '2026-03-15T10:25:00.000Z'
+                    initiatives: [initiative],
+                    workstreams: [workstream],
+                    workstreamTaskSummaries: [],
                 });
             }
-            if (url.includes('/api/taskforce/data-version')) {
+            if (url.includes('/api/taskforce/data-version'))
                 return jsonResponse({ dataVersion: 1 });
-            }
             return jsonResponse({});
         }));
         const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
         await waitFor(() => {
-            expect(result.current.tasks.some((task) => task.id === 'task-parent')).toBe(true);
-        });
-        await act(async () => {
-            await result.current.handleToggleComplete(activeTask);
+            expect(planningBootstrapCalls).toBeGreaterThanOrEqual(1);
         });
         await waitFor(() => {
-            const completed = result.current.tasks.find((task) => task.id === 'task-parent');
-            expect(completed?.status).toBe('done');
-            expect(completed?.completedAt).toBe('2026-03-15T10:25:00.000Z');
+            expect(result.current.tasks.some((task) => task.id === activeTask.id)).toBe(true);
         });
-    });
-    it('merges bulk-archived tasks immediately instead of relying on archive refresh timing', async () => {
-        vi.stubGlobal('confirm', vi.fn(() => true));
-        vi.stubGlobal('fetch', vi.fn((url, init) => {
+        await waitFor(() => {
+            expect(result.current.initiatives.some((item) => item.id === initiative.id)).toBe(true);
+            expect(result.current.workstreams.some((item) => item.id === workstream.id)).toBe(true);
+        }, { timeout: 7000 });
+    }, 10000);
+    it('does not block cloud bootstrap readiness on a slow planning bootstrap response', async () => {
+        const delayedPlanningResponseMs = 1500;
+        vi.stubGlobal('fetch', vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'single-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: false
+                    }
+                });
             }
-            if (url.includes('/api/taskforce/ui-state?key=app')) {
-                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
             }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
             if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
                 return jsonResponse({
                     success: true,
@@ -430,148 +520,2192 @@ describe('useTaskforce sync behavior', () => {
             }
             if (url.includes('/api/taskforce/config')) {
                 return jsonResponse({
-                    projectName: 'Test Project',
-                    workspaceId: 'workspace-local-active',
-                    runtimeMode: 'local',
+                    projectName: 'Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
                     setupState: {
                         globalSetupState: 'complete',
                         workspaceSetupState: 'complete',
-                        workspaceId: 'workspace-local-active'
+                        workspaceId: 'workspace-cloud-1'
                     }
                 });
             }
-            if (url.includes('/api/taskforce/global-settings')) {
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: 'general', label: 'General' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
                 return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve({
+                            ok: true,
+                            status: 200,
+                            json: () => Promise.resolve({
+                                initiatives: [{
+                                        id: 'initiative-slow-1',
+                                        title: 'Slow initiative',
+                                        description: null,
+                                        createdAt: '2026-03-15T10:00:00.000Z',
+                                    }],
+                                workstreams: [],
+                                workstreamTaskSummaries: []
+                            })
+                        });
+                    }, delayedPlanningResponseMs);
+                });
             }
-            if (url.includes('/api/taskforce/categories')) {
-                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.tasks.some((task) => task.id === activeTask.id)).toBe(true);
+            expect(result.current.bootstrapState.pending).toBe(false);
+            expect(result.current.bootstrapState.ready).toBe(true);
+        }, { timeout: 700 });
+        expect(result.current.initiatives).toEqual([]);
+        await waitFor(() => {
+            expect(result.current.initiatives.some((initiative) => initiative.id === 'initiative-slow-1')).toBe(true);
+        }, { timeout: 2500 });
+    });
+    it('loads cloud assignee options only once during initial bootstrap', async () => {
+        let assigneeRequestCount = 0;
+        vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'single-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: false
+                    }
+                });
             }
-            if (url.includes('/api/taskforce/types')) {
-                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
             }
-            if (url.includes('/api/taskforce/priorities')) {
-                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
             }
-            if (url.includes('/api/taskforce/approaches')) {
-                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: 'general', label: 'General' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options')) {
+                assigneeRequestCount += 1;
+                return jsonResponse({ assignees: [] });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.tasks.some((task) => task.id === activeTask.id)).toBe(true);
+            expect(result.current.bootstrapState.pending).toBe(false);
+            expect(result.current.bootstrapState.ready).toBe(true);
+        }, { timeout: 2500 });
+        await waitFor(() => {
+            expect(assigneeRequestCount).toBe(1);
+        }, { timeout: 2500 });
+    });
+    it('keeps the dawn theme when settings re-fetch configuration', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: false,
+                    authRequiredForApi: false,
+                    betaAccess: true,
+                    userId: 'anonymous',
+                    email: '',
+                    workspaceId: 'workspace-local-active'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    theme: 'dawn',
+                    globalTheme: 'dawn',
+                    themeUseGlobalDefault: true,
+                    projectName: 'Test Project',
+                    workspaceId: 'workspace-local-active',
+                    runtimeMode: 'local',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-local-active'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentTheme).toBe('dawn');
+        });
+        await act(async () => {
+            result.current.setIsOpen(true);
+            result.current.setActiveTab('settings');
+        });
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.filter(([url]) => String(url).includes('/api/taskforce/config'))).toHaveLength(2);
+            expect(result.current.currentTheme).toBe('dawn');
+        });
+    });
+    it('merges a server-returned archived task immediately instead of dropping it between collections', async () => {
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Test Project',
+                    workspaceId: 'workspace-local-active',
+                    runtimeMode: 'local',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-local-active'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings')) {
+                return jsonResponse({});
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return jsonResponse({ types: [] });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return jsonResponse({ priorities: [] });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return jsonResponse({ approaches: [] });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return jsonResponse({ specialists: [] });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: [activeTask] });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/task/task-parent/complete') && String(init?.method || '').toUpperCase() === 'POST') {
+                return jsonResponse({
+                    ...activeTask,
+                    status: 'done',
+                    isArchived: true,
+                    completedAt: '2026-03-15T10:20:00.000Z',
+                    updatedAt: '2026-03-15T10:20:00.000Z'
+                });
+            }
+            if (url.includes('/api/taskforce/data-version')) {
+                return jsonResponse({ dataVersion: 1 });
+            }
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.tasks.some((task) => task.id === 'task-parent')).toBe(true);
+        });
+        await act(async () => {
+            await result.current.handleArchiveTask(activeTask);
+        });
+        await waitFor(() => {
+            expect(result.current.tasks.some((task) => task.id === 'task-parent')).toBe(false);
+            const archived = result.current.archivedTasks.find((task) => task.id === 'task-parent');
+            expect(archived?.isArchived).toBe(true);
+            expect(archived?.status).toBe('done');
+        });
+    });
+    it('merges a server-returned completed task immediately when toggling done', async () => {
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Test Project',
+                    workspaceId: 'workspace-local-active',
+                    runtimeMode: 'local',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-local-active'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings')) {
+                return jsonResponse({});
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return jsonResponse({ types: [] });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return jsonResponse({ priorities: [] });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return jsonResponse({ approaches: [] });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return jsonResponse({ specialists: [] });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: [activeTask] });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/task/task-parent') && String(init?.method || '').toUpperCase() === 'PATCH') {
+                return jsonResponse({
+                    ...activeTask,
+                    status: 'done',
+                    completedAt: '2026-03-15T10:25:00.000Z',
+                    updatedAt: '2026-03-15T10:25:00.000Z'
+                });
+            }
+            if (url.includes('/api/taskforce/data-version')) {
+                return jsonResponse({ dataVersion: 1 });
+            }
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.tasks.some((task) => task.id === 'task-parent')).toBe(true);
+        });
+        await act(async () => {
+            await result.current.handleToggleComplete(activeTask);
+        });
+        await waitFor(() => {
+            const completed = result.current.tasks.find((task) => task.id === 'task-parent');
+            expect(completed?.status).toBe('done');
+            expect(completed?.completedAt).toBe('2026-03-15T10:25:00.000Z');
+        });
+    });
+    it('merges bulk-archived tasks immediately instead of relying on archive refresh timing', async () => {
+        vi.stubGlobal('confirm', vi.fn(() => true));
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Test Project',
+                    workspaceId: 'workspace-local-active',
+                    runtimeMode: 'local',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-local-active'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings')) {
+                return jsonResponse({});
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return jsonResponse({ types: [] });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return jsonResponse({ priorities: [] });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return jsonResponse({ approaches: [] });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return jsonResponse({ specialists: [] });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: [activeTask, doneTask] });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/bulk-archive') && String(init?.method || '').toUpperCase() === 'POST') {
+                return jsonResponse({
+                    success: true,
+                    results: {
+                        archived: [
+                            {
+                                ...doneTask,
+                                isArchived: true
+                            }
+                        ]
+                    },
+                    errors: []
+                });
+            }
+            if (url.includes('/api/taskforce/data-version')) {
+                return jsonResponse({ dataVersion: 1 });
+            }
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.tasks.some((task) => task.id === 'task-done')).toBe(true);
+        });
+        await act(async () => {
+            await result.current.handleBulkArchive();
+        });
+        await waitFor(() => {
+            expect(result.current.tasks.some((task) => task.id === 'task-done')).toBe(false);
+            const archived = result.current.archivedTasks.find((task) => task.id === 'task-done');
+            expect(archived?.isArchived).toBe(true);
+            expect(archived?.status).toBe('done');
+        });
+    });
+    it('preserves an explicit local api base url instead of letting runtime-config reset it to the app origin', async () => {
+        vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'local',
+                        workspaceMode: 'single-local',
+                        authSource: 'cloud',
+                        baseUrl: 'http://localhost:5174',
+                        apiBaseUrl: 'http://localhost:5174',
+                        cloudAuthBaseUrl: 'http://localhost:5174'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Test Project',
+                    workspaceId: 'workspace-local-active',
+                    runtimeMode: 'local',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-local-active'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings')) {
+                return jsonResponse({});
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return jsonResponse({ types: [] });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return jsonResponse({ priorities: [] });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return jsonResponse({ approaches: [] });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return jsonResponse({ specialists: [] });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: [activeTask] });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/data-version')) {
+                return jsonResponse({ dataVersion: 1 });
+            }
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { apiBaseUrl: 'http://127.0.0.1:4280' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.config.apiBaseUrl).toBe('http://127.0.0.1:4280');
+        });
+    });
+    it('opens archived tasks by id and enables archive view', async () => {
+        vi.stubGlobal('WebSocket', MockWebSocket);
+        const archivedChildren = [
+            archivedTaskRecord('task-archived-child-1', 'Archived Task 1')
+        ];
+        vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    realtimeSyncEnabled: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: archivedChildren });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.archivedTasks.some((task) => task.id === 'task-archived-child-1')).toBe(true);
+        }, { timeout: 2500 });
+        act(() => {
+            result.current.handleOpenTaskById('task-archived-child-1');
+        });
+        await waitFor(() => {
+            expect(result.current.showArchive).toBe(true);
+            expect(result.current.editingTaskId).toBe('task-archived-child-1');
+            expect(result.current.currentTask?.isArchived).toBe(true);
+        });
+    });
+    it('hydrates cloud taxonomy filters when commercial onboarding continues into the app', async () => {
+        let configResolved = false;
+        let allowResolvedTaxonomyState = false;
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: 'workspace-cloud-1',
+                    workspaces: [
+                        { id: 'workspace-cloud-1', name: 'Cloud Workspace', role: 'owner' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        configResolved = true;
+                        resolve({
+                            ok: true,
+                            status: 200,
+                            json: () => Promise.resolve({
+                                projectName: 'Cloud Project',
+                                workspaceId: 'workspace-cloud-1',
+                                runtimeMode: 'cloud',
+                                authRequiredForApi: true,
+                                userId: 'user-1',
+                                setupState: {
+                                    globalSetupState: 'complete',
+                                    workspaceSetupState: 'complete',
+                                    workspaceId: 'workspace-cloud-1'
+                                }
+                            })
+                        });
+                    }, 25);
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse(configResolved && allowResolvedTaxonomyState ? {
+                    categories: [{ value: 'cloud-ops', label: 'Cloud Ops' }],
+                    types: [{ value: 'incident', label: 'Incident' }],
+                    priorities: [{ value: 4, label: 'Critical' }],
+                    taxonomies: []
+                } : {
+                    categories: [],
+                    types: [],
+                    priorities: [],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.authSessionResolved).toBe(true);
+            expect(result.current.isAuthenticated).toBe(true);
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+        }, { timeout: 2500 });
+        expect(result.current.activeCategories.some((category) => category.value === 'cloud-ops')).toBe(false);
+        allowResolvedTaxonomyState = true;
+        await act(async () => {
+            const outcome = await result.current.continueAfterCommercialOnboarding();
+            expect(outcome).toEqual({ success: true, destination: 'app' });
+        });
+        await waitFor(() => {
+            expect(result.current.activeCategories.some((category) => category.value === 'cloud-ops')).toBe(true);
+            expect(result.current.activeTypes.some((type) => type.value === 'incident')).toBe(true);
+            expect(result.current.priorities.some((priority) => priority.value === 4)).toBe(true);
+        }, { timeout: 2500 });
+    });
+    it('uses unified taxonomy-state payloads without falling back to category endpoints during cloud bootstrap', async () => {
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: 'workspace-cloud-1',
+                    workspaces: [{ id: 'workspace-cloud-1', name: 'Cloud Workspace', role: 'owner' }]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace'))
+                return jsonResponse({ success: true });
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: 'cloud-ops', label: 'Cloud Ops' }],
+                    types: [{ value: 'incident', label: 'Incident' }],
+                    priorities: [{ value: 4, label: 'Critical' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+            expect(result.current.activeCategories.some((category) => category.value === 'cloud-ops')).toBe(true);
+        }, { timeout: 2500 });
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/categories'))).toBe(false);
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/types'))).toBe(false);
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/priorities'))).toBe(false);
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/taxonomies'))).toBe(false);
+    });
+    it('defers the initial cloud bootstrap on a real cloud host until auth resolves so taxonomy and planning data still load', async () => {
+        const windowProxy = new Proxy(window, {
+            get(target, prop, receiver) {
+                if (prop === 'location') {
+                    return {
+                        ...target.location,
+                        hostname: 'app.taskforce.test'
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            }
+        });
+        vi.stubGlobal('window', windowProxy);
+        let runtimeConfigResolved = false;
+        let authSessionResolved = false;
+        const prematureProtectedCalls = [];
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return new Promise((resolve) => {
+                    window.setTimeout(() => {
+                        runtimeConfigResolved = true;
+                        resolve({
+                            ok: true,
+                            status: 200,
+                            json: () => Promise.resolve({
+                                config: {
+                                    runtimeMode: 'cloud',
+                                    workspaceMode: 'multi-cloud',
+                                    authSource: 'cloud',
+                                    workspaceSwitchingEnabled: true
+                                }
+                            })
+                        });
+                    }, 20);
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return new Promise((resolve) => {
+                    window.setTimeout(() => {
+                        authSessionResolved = true;
+                        resolve({
+                            ok: true,
+                            status: 200,
+                            json: () => Promise.resolve({
+                                authenticated: true,
+                                authRequiredForApi: true,
+                                betaAccess: true,
+                                userId: 'user-1',
+                                email: 'user@example.com',
+                                workspaceId: 'workspace-cloud-1'
+                            })
+                        });
+                    }, runtimeConfigResolved ? 20 : 40);
+                });
+            }
+            if ((url.includes('/api/taskforce/config')
+                || url.includes('/api/taskforce/taxonomy-state')
+                || url.includes('/api/taskforce/planning/bootstrap')
+                || url.includes('/api/taskforce/tasks'))
+                && !authSessionResolved) {
+                prematureProtectedCalls.push(url);
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: 'workspace-cloud-1',
+                    workspaces: [{ id: 'workspace-cloud-1', name: 'Cloud Workspace', role: 'owner' }]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace'))
+                return jsonResponse({ success: true });
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: 'cloud-ops', label: 'Cloud Ops' }],
+                    types: [{ value: 'incident', label: 'Incident' }],
+                    priorities: [{ value: 4, label: 'Critical' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options')) {
+                return jsonResponse({
+                    assignees: [
+                        { userId: 'member-1', email: 'member1@example.com', displayName: 'Member One', status: 'active', disabled: false },
+                        { value: 'ai-profile-codex', label: 'Codex', icon: 'Bot', color: '#0ea5e9', kind: 'agent' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members')) {
+                return jsonResponse({
+                    users: [
+                        {
+                            userId: 'user-1',
+                            email: 'user@example.com',
+                            displayName: 'Signed In Owner',
+                            role: 'owner',
+                            status: 'active',
+                            disabled: false
+                        },
+                        {
+                            userId: 'member-1',
+                            email: 'member1@example.com',
+                            displayName: 'Member One',
+                            status: 'active',
+                            disabled: false
+                        }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                return jsonResponse({
+                    initiatives: [{
+                            id: 'initiative-1',
+                            title: 'Cloud Initiative',
+                            description: '',
+                            ownerId: null,
+                            createdAt: '2026-03-15T10:00:00.000Z',
+                            updatedAt: '2026-03-15T10:00:00.000Z',
+                            referenceNumber: 5,
+                            referenceLabel: 'IN-5',
+                            isArchived: false,
+                            comments: [],
+                            attachments: []
+                        }],
+                    workstreams: [{
+                            id: 'workstream-1',
+                            title: 'Cloud Workstream',
+                            description: '',
+                            ownerId: null,
+                            initiativeId: 'initiative-1',
+                            createdAt: '2026-03-15T10:05:00.000Z',
+                            updatedAt: '2026-03-15T10:05:00.000Z',
+                            referenceNumber: 10,
+                            referenceLabel: 'WS-10',
+                            isArchived: false,
+                            comments: [],
+                            attachments: []
+                        }],
+                    workstreamTaskSummaries: []
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.authSessionResolved).toBe(true);
+            expect(result.current.isAuthenticated).toBe(true);
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+            expect(result.current.activeCategories.some((category) => category.value === 'cloud-ops')).toBe(true);
+            expect(result.current.initiatives.some((initiative) => initiative.id === 'initiative-1')).toBe(true);
+            expect(result.current.workstreams.some((workstream) => workstream.id === 'workstream-1')).toBe(true);
+            expect(result.current.assigneeOptions.some((option) => option.value === 'member-1' && option.label === 'Member One')).toBe(true);
+            expect(result.current.assigneeOptions.some((option) => option.value === 'ai-profile-codex' && option.label === 'Codex')).toBe(true);
+        }, { timeout: 2500 });
+        expect(prematureProtectedCalls).toEqual([]);
+    });
+    it('falls back to category endpoints when taxonomy-state payload is unavailable during cloud bootstrap', async () => {
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: 'workspace-cloud-1',
+                    workspaces: [{ id: 'workspace-cloud-1', name: 'Cloud Workspace', role: 'owner' }]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace'))
+                return jsonResponse({ success: true });
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'cloud-ops', label: 'Cloud Ops' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [{ value: 'incident', label: 'Incident' }] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [{ value: 4, label: 'Critical' }] });
+            if (url.includes('/api/taskforce/taxonomies'))
+                return jsonResponse({ taxonomies: [] });
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+            expect(result.current.activeCategories.some((category) => category.value === 'cloud-ops')).toBe(true);
+            expect(result.current.activeTypes.some((type) => type.value === 'incident')).toBe(true);
+            expect(result.current.priorities.some((priority) => priority.value === 4)).toBe(true);
+        }, { timeout: 2500 });
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/categories'))).toBe(true);
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/types'))).toBe(true);
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/priorities'))).toBe(true);
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/taxonomies'))).toBe(true);
+    });
+    it('rehydrates taxonomy state for the newly selected workspace after a cloud workspace switch', async () => {
+        let sessionWorkspaceId = 'workspace-cloud-1';
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: sessionWorkspaceId
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: sessionWorkspaceId,
+                    workspaces: [
+                        { id: 'workspace-cloud-1', name: 'Cloud Workspace 1', role: 'owner' },
+                        { id: 'workspace-cloud-2', name: 'Cloud Workspace 2', role: 'owner' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                sessionWorkspaceId = String(body.workspaceId || '').trim() || sessionWorkspaceId;
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: sessionWorkspaceId === 'workspace-cloud-2' ? 'Cloud Project 2' : 'Cloud Project 1',
+                    workspaceId: sessionWorkspaceId,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: sessionWorkspaceId
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                if (sessionWorkspaceId === 'workspace-cloud-2') {
+                    return jsonResponse({
+                        categories: [{ value: 'workspace-two', label: 'Workspace Two' }],
+                        types: [{ value: 'incident', label: 'Incident' }],
+                        priorities: [{ value: 4, label: 'Critical' }],
+                        taxonomies: []
+                    });
+                }
+                return jsonResponse({
+                    categories: [{ value: 'workspace-one', label: 'Workspace One' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+            expect(result.current.activeCategories.some((category) => category.value === 'workspace-one')).toBe(true);
+        }, { timeout: 2500 });
+        await act(async () => {
+            const switched = await result.current.switchWorkspace('workspace-cloud-2');
+            expect(switched).toEqual({ success: true });
+        });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-2');
+            expect(result.current.activeCategories.some((category) => category.value === 'workspace-two')).toBe(true);
+            expect(result.current.activeCategories.some((category) => category.value === 'workspace-one')).toBe(false);
+            expect(result.current.activeTypes.some((type) => type.value === 'incident')).toBe(true);
+            expect(result.current.activeTypes.some((type) => type.value === 'feature')).toBe(false);
+            expect(result.current.priorities.some((priority) => priority.value === 4)).toBe(true);
+        }, { timeout: 2500 });
+    });
+    it('rehydrates assignee options and workspace role for the newly selected cloud workspace after a workspace switch', async () => {
+        let sessionWorkspaceId = 'workspace-cloud-1';
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: sessionWorkspaceId
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: sessionWorkspaceId,
+                    workspaces: [
+                        { id: 'workspace-cloud-1', name: 'Cloud Workspace 1', role: 'owner' },
+                        { id: 'workspace-cloud-2', name: 'Cloud Workspace 2', role: 'member' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                sessionWorkspaceId = String(body.workspaceId || '').trim() || sessionWorkspaceId;
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: sessionWorkspaceId === 'workspace-cloud-2' ? 'Cloud Project 2' : 'Cloud Project 1',
+                    workspaceId: sessionWorkspaceId,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: sessionWorkspaceId
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: sessionWorkspaceId === 'workspace-cloud-2' ? 'workspace-two' : 'workspace-one', label: 'Workspace' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members')) {
+                if (sessionWorkspaceId === 'workspace-cloud-2') {
+                    return jsonResponse({
+                        users: [
+                            {
+                                userId: 'user-1',
+                                email: 'user@example.com',
+                                displayName: 'Signed In User',
+                                role: 'member',
+                                status: 'active',
+                                disabled: false
+                            },
+                            {
+                                userId: 'member-2',
+                                email: 'member2@example.com',
+                                displayName: 'Workspace Two Member',
+                                status: 'active',
+                                disabled: false
+                            }
+                        ]
+                    });
+                }
+                return jsonResponse({
+                    users: [
+                        {
+                            userId: 'user-1',
+                            email: 'user@example.com',
+                            displayName: 'Signed In User',
+                            role: 'owner',
+                            status: 'active',
+                            disabled: false
+                        },
+                        {
+                            userId: 'member-1',
+                            email: 'member1@example.com',
+                            displayName: 'Workspace One Member',
+                            status: 'active',
+                            disabled: false
+                        }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/workspace/assignee-options')) {
+                if (sessionWorkspaceId === 'workspace-cloud-2') {
+                    return jsonResponse({
+                        assignees: [
+                            { userId: 'member-2', email: 'member2@example.com', displayName: 'Workspace Two Member', status: 'active', disabled: false },
+                            { value: 'ai-profile-reviewer', label: 'Reviewer', icon: 'Bot', color: '#0ea5e9', kind: 'agent' }
+                        ]
+                    });
+                }
+                return jsonResponse({
+                    assignees: [
+                        { userId: 'member-1', email: 'member1@example.com', displayName: 'Workspace One Member', status: 'active', disabled: false },
+                        { value: 'ai-profile-codex', label: 'Codex', icon: 'Bot', color: '#0ea5e9', kind: 'agent' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+            expect(result.current.currentWorkspaceRole).toBe('owner');
+            expect(result.current.assigneeOptions.some((option) => option.value === 'member-1' && option.label === 'Workspace One Member')).toBe(true);
+            expect(result.current.assigneeOptions.some((option) => option.value === 'ai-profile-codex' && option.label === 'Codex')).toBe(true);
+        }, { timeout: 2500 });
+        await act(async () => {
+            const switched = await result.current.switchWorkspace('workspace-cloud-2');
+            expect(switched).toEqual({ success: true });
+        });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-2');
+            expect(result.current.currentWorkspaceRole).toBe('member');
+            expect(result.current.assigneeOptions.some((option) => option.value === 'member-2' && option.label === 'Workspace Two Member')).toBe(true);
+            expect(result.current.assigneeOptions.some((option) => option.value === 'member-1')).toBe(false);
+            expect(result.current.assigneeOptions.some((option) => option.value === 'ai-profile-reviewer' && option.label === 'Reviewer')).toBe(true);
+            expect(result.current.assigneeOptions.some((option) => option.value === 'ai-profile-codex')).toBe(false);
+        }, { timeout: 2500 });
+    });
+    it('starts planning bootstrap before deferred assignee hydration after a cloud workspace switch', async () => {
+        let sessionWorkspaceId = 'workspace-cloud-1';
+        const requestOrder = [];
+        let resolveWorkspaceTwoAssignees = null;
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: sessionWorkspaceId
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST')
+                    return jsonResponse({ success: true });
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: sessionWorkspaceId,
+                    workspaces: [
+                        { id: 'workspace-cloud-1', name: 'Cloud Workspace 1', role: 'owner' },
+                        { id: 'workspace-cloud-2', name: 'Cloud Workspace 2', role: 'member' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                sessionWorkspaceId = String(body.workspaceId || '').trim() || sessionWorkspaceId;
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: sessionWorkspaceId === 'workspace-cloud-2' ? 'Cloud Project 2' : 'Cloud Project 1',
+                    workspaceId: sessionWorkspaceId,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: sessionWorkspaceId
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: sessionWorkspaceId === 'workspace-cloud-2' ? 'workspace-two' : 'workspace-one', label: 'Workspace' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options')) {
+                requestOrder.push(`assignee:${sessionWorkspaceId}`);
+                if (sessionWorkspaceId === 'workspace-cloud-2') {
+                    return new Promise((resolve) => {
+                        resolveWorkspaceTwoAssignees = () => resolve({
+                            ok: true,
+                            status: 200,
+                            json: () => Promise.resolve({ assignees: [] })
+                        });
+                    });
+                }
+                return jsonResponse({ assignees: [] });
+            }
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                requestOrder.push(`planning:${sessionWorkspaceId}`);
+                return jsonResponse({
+                    initiatives: [{ id: `initiative-${sessionWorkspaceId}`, title: `Initiative ${sessionWorkspaceId}` }],
+                    workstreams: [],
+                    workstreamTaskSummaries: []
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+            expect(result.current.initiatives.some((initiative) => initiative.id === 'initiative-workspace-cloud-1')).toBe(true);
+        }, { timeout: 2500 });
+        requestOrder.length = 0;
+        await act(async () => {
+            const switched = await result.current.switchWorkspace('workspace-cloud-2');
+            expect(switched).toEqual({ success: true });
+        });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-2');
+            expect(result.current.initiatives.some((initiative) => initiative.id === 'initiative-workspace-cloud-2')).toBe(true);
+        }, { timeout: 2500 });
+        await waitFor(() => {
+            expect(requestOrder).toContain('planning:workspace-cloud-2');
+            expect(requestOrder).toContain('assignee:workspace-cloud-2');
+        }, { timeout: 2500 });
+        expect(requestOrder.indexOf('planning:workspace-cloud-2')).toBeLessThan(requestOrder.indexOf('assignee:workspace-cloud-2'));
+        await act(async () => {
+            resolveWorkspaceTwoAssignees?.();
+        });
+    });
+    it('rehydrates planning bootstrap outputs for the newly selected cloud workspace after a workspace switch', async () => {
+        let sessionWorkspaceId = 'workspace-cloud-1';
+        const planningBootstrapWorkspaces = [];
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: sessionWorkspaceId
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: sessionWorkspaceId,
+                    workspaces: [
+                        { id: 'workspace-cloud-1', name: 'Cloud Workspace 1', role: 'owner' },
+                        { id: 'workspace-cloud-2', name: 'Cloud Workspace 2', role: 'member' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                sessionWorkspaceId = String(body.workspaceId || '').trim() || sessionWorkspaceId;
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: sessionWorkspaceId === 'workspace-cloud-2' ? 'Cloud Project 2' : 'Cloud Project 1',
+                    workspaceId: sessionWorkspaceId,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: sessionWorkspaceId
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: sessionWorkspaceId === 'workspace-cloud-2' ? 'workspace-two' : 'workspace-one', label: 'Workspace' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                planningBootstrapWorkspaces.push(sessionWorkspaceId);
+                if (sessionWorkspaceId === 'workspace-cloud-2') {
+                    return jsonResponse({
+                        initiatives: [
+                            {
+                                id: 'initiative-2',
+                                title: 'Workspace Two Initiative',
+                                description: 'Workspace two planning initiative',
+                                ownerId: null,
+                                createdAt: '2026-03-15T10:20:00.000Z',
+                                updatedAt: '2026-03-15T10:20:00.000Z',
+                                referenceNumber: 12,
+                                referenceLabel: 'IN-12',
+                                isArchived: false,
+                                comments: [],
+                                attachments: []
+                            }
+                        ],
+                        workstreams: [
+                            {
+                                id: 'workstream-2',
+                                title: 'Workspace Two Workstream',
+                                description: 'Workspace two workstream',
+                                ownerId: null,
+                                initiativeId: 'initiative-2',
+                                createdAt: '2026-03-15T10:25:00.000Z',
+                                updatedAt: '2026-03-15T10:25:00.000Z',
+                                referenceNumber: 102,
+                                referenceLabel: 'WS-102',
+                                isArchived: false,
+                                comments: [],
+                                attachments: []
+                            }
+                        ],
+                        workstreamTaskSummaries: [{
+                                workstreamId: 'workstream-2',
+                                taskCount: 1,
+                                completedTaskCount: 0,
+                                tasks: [{
+                                        id: 'task-workspace-2',
+                                        title: 'Workspace Two Task',
+                                        status: 'task'
+                                    }]
+                            }]
+                    });
+                }
+                return jsonResponse({
+                    initiatives: [
+                        {
+                            id: 'initiative-1',
+                            title: 'Workspace One Initiative',
+                            description: 'Workspace one planning initiative',
+                            ownerId: null,
+                            createdAt: '2026-03-15T10:00:00.000Z',
+                            updatedAt: '2026-03-15T10:00:00.000Z',
+                            referenceNumber: 11,
+                            referenceLabel: 'IN-11',
+                            isArchived: false,
+                            comments: [],
+                            attachments: []
+                        }
+                    ],
+                    workstreams: [
+                        {
+                            id: 'workstream-1',
+                            title: 'Workspace One Workstream',
+                            description: 'Workspace one workstream',
+                            ownerId: null,
+                            initiativeId: 'initiative-1',
+                            createdAt: '2026-03-15T10:05:00.000Z',
+                            updatedAt: '2026-03-15T10:05:00.000Z',
+                            referenceNumber: 101,
+                            referenceLabel: 'WS-101',
+                            isArchived: false,
+                            comments: [],
+                            attachments: []
+                        }
+                    ],
+                    workstreamTaskSummaries: [{
+                            workstreamId: 'workstream-1',
+                            taskCount: 1,
+                            completedTaskCount: 0,
+                            tasks: [{
+                                    id: 'task-workspace-1',
+                                    title: 'Workspace One Task',
+                                    status: 'task'
+                                }]
+                        }]
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+            expect(result.current.initiatives.some((initiative) => initiative.id === 'initiative-1')).toBe(true);
+            expect(result.current.workstreams.some((workstream) => workstream.id === 'workstream-1')).toBe(true);
+        }, { timeout: 2500 });
+        await act(async () => {
+            const switched = await result.current.switchWorkspace('workspace-cloud-2');
+            expect(switched).toEqual({ success: true });
+        });
+        await waitFor(() => {
+            expect(planningBootstrapWorkspaces).toContain('workspace-cloud-2');
+        }, { timeout: 2500 });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-2');
+            expect(result.current.initiatives.map((initiative) => initiative.id)).toEqual(['initiative-2']);
+            expect(result.current.workstreams.map((workstream) => workstream.id)).toEqual(['workstream-2']);
+        }, { timeout: 2500 });
+        expect(consoleErrorSpy).not.toHaveBeenCalledWith('[Taskforce] Failed to fetch planning entities:', 'superseded');
+    });
+    it('does not log expected workspace-transition aborts during cloud workspace switches', async () => {
+        let sessionWorkspaceId = 'workspace-cloud-1';
+        let deletedAbortSeen = false;
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const rejectOnAbort = (init, errorFactory) => new Promise((_resolve, reject) => {
+            const signal = init?.signal;
+            if (!signal)
+                return;
+            const onAbort = () => reject(errorFactory(signal));
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+            signal.addEventListener('abort', onAbort, { once: true });
+        });
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: sessionWorkspaceId
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: sessionWorkspaceId,
+                    workspaces: [
+                        { id: 'workspace-cloud-1', name: 'Cloud Workspace 1', role: 'owner' },
+                        { id: 'workspace-cloud-2', name: 'Cloud Workspace 2', role: 'member' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                sessionWorkspaceId = String(body.workspaceId || '').trim() || sessionWorkspaceId;
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Cloud Project',
+                    workspaceId: sessionWorkspaceId,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: sessionWorkspaceId
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: 'general', label: 'General' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                if (sessionWorkspaceId === 'workspace-cloud-1') {
+                    return rejectOnAbort(init, (signal) => signal.reason || new TypeError('Failed to fetch'));
+                }
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            }
+            if (url.includes('/api/taskforce/deleted')) {
+                return rejectOnAbort(init, () => {
+                    deletedAbortSeen = true;
+                    return new TypeError('Failed to fetch');
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        try {
+            const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+            await waitFor(() => {
+                expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+                expect(result.current.bootstrapState.ready).toBe(true);
+            }, { timeout: 2500 });
+            act(() => {
+                void result.current.fetchDeletedTasks(true);
+            });
+            await act(async () => {
+                const switched = await result.current.switchWorkspace('workspace-cloud-2', { hydrate: false });
+                expect(switched).toEqual({ success: true });
+            });
+            await waitFor(() => {
+                expect(result.current.currentWorkspaceId).toBe('workspace-cloud-2');
+                expect(deletedAbortSeen).toBe(true);
+            }, { timeout: 2500 });
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith('[Taskforce] Failed to fetch planning entities:', 'workspace-transition');
+            expect(consoleErrorSpy).not.toHaveBeenCalledWith('[Taskforce] Failed to fetch deleted tasks:', expect.any(TypeError));
+        }
+        finally {
+            consoleErrorSpy.mockRestore();
+        }
+    });
+    it('uses the preferred workspace returned by invite join during cloud re-entry', async () => {
+        let sessionWorkspaceId = 'workspace-home';
+        const sessionWorkspacePosts = [];
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true,
+                        cloudAuthBaseUrl: 'https://cloud.example.com'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: sessionWorkspaceId
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: sessionWorkspaceId,
+                    workspaces: [
+                        { id: 'workspace-home', name: 'Home Workspace', role: 'owner' },
+                        { id: 'workspace-invite', name: 'Invited Workspace', role: 'member' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                const nextWorkspaceId = String(body.workspaceId || '').trim();
+                sessionWorkspacePosts.push(nextWorkspaceId);
+                sessionWorkspaceId = nextWorkspaceId || sessionWorkspaceId;
+                return jsonResponse({ success: true, workspaceId: sessionWorkspaceId });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: sessionWorkspaceId === 'workspace-invite' ? 'Invited Workspace' : 'Home Workspace',
+                    workspaceId: sessionWorkspaceId,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: sessionWorkspaceId
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: sessionWorkspaceId === 'workspace-invite' ? 'invite' : 'home', label: 'Workspace' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/auth/invite/join')) {
+                return jsonResponse({ success: true, workspaceId: 'workspace-invite' });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-home');
+            expect(result.current.runtimeMode).toBe('cloud');
+            expect(result.current.workspaceSwitchingEnabled).toBe(true);
+        }, { timeout: 2500 });
+        await act(async () => {
+            const joined = await result.current.joinInviteWithToken('invite-token');
+            expect(joined).toEqual({ success: true, workspaceSetupRequired: false });
+        });
+        await waitFor(() => {
+            expect(sessionWorkspacePosts).toContain('workspace-invite');
+        }, { timeout: 2500 });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-invite');
+        }, { timeout: 2500 });
+    });
+    it('uses the preferred workspace returned by invite acceptance during cloud re-entry', async () => {
+        let sessionWorkspaceId = 'workspace-home';
+        const sessionWorkspacePosts = [];
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true,
+                        cloudAuthBaseUrl: 'https://cloud.example.com'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'new@example.com',
+                    workspaceId: sessionWorkspaceId
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
             }
-            if (url.includes('/api/taskforce/specialists')) {
-                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: sessionWorkspaceId,
+                    workspaces: [
+                        { id: 'workspace-home', name: 'Home Workspace', role: 'owner' },
+                        { id: 'workspace-invite', name: 'Invited Workspace', role: 'member' }
+                    ]
+                });
             }
-            if (url.includes('/api/taskforce/tasks')) {
-                return jsonResponse({ tasks: [activeTask, doneTask] });
+            if (url.includes('/api/taskforce/session/workspace')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                const nextWorkspaceId = String(body.workspaceId || '').trim();
+                sessionWorkspacePosts.push(nextWorkspaceId);
+                sessionWorkspaceId = nextWorkspaceId || sessionWorkspaceId;
+                return jsonResponse({ success: true, workspaceId: sessionWorkspaceId });
             }
-            if (url.includes('/api/taskforce/archive')) {
-                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: sessionWorkspaceId === 'workspace-invite' ? 'Invited Workspace' : 'Home Workspace',
+                    workspaceId: sessionWorkspaceId,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: sessionWorkspaceId
+                    }
+                });
             }
-            if (url.includes('/api/taskforce/bulk-archive') && String(init?.method || '').toUpperCase() === 'POST') {
+            if (url.includes('/api/taskforce/taxonomy-state')) {
                 return jsonResponse({
-                    success: true,
-                    results: {
-                        archived: [
-                            {
-                                ...doneTask,
-                                isArchived: true
-                            }
-                        ]
-                    },
-                    errors: []
+                    categories: [{ value: sessionWorkspaceId === 'workspace-invite' ? 'invite' : 'home', label: 'Workspace' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
                 });
             }
-            if (url.includes('/api/taskforce/data-version')) {
-                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/auth/invite/accept')) {
+                return jsonResponse({ success: true, workspaceId: 'workspace-invite' });
             }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
             return jsonResponse({});
         }));
-        const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
         await waitFor(() => {
-            expect(result.current.tasks.some((task) => task.id === 'task-done')).toBe(true);
-        });
+            expect(result.current.currentWorkspaceId).toBe('workspace-home');
+            expect(result.current.runtimeMode).toBe('cloud');
+            expect(result.current.workspaceSwitchingEnabled).toBe(true);
+        }, { timeout: 2500 });
         await act(async () => {
-            await result.current.handleBulkArchive();
+            const accepted = await result.current.acceptInviteWithToken('invite-token', 'NewUserPass123!');
+            expect(accepted).toEqual({ success: true, workspaceSetupRequired: false });
         });
         await waitFor(() => {
-            expect(result.current.tasks.some((task) => task.id === 'task-done')).toBe(false);
-            const archived = result.current.archivedTasks.find((task) => task.id === 'task-done');
-            expect(archived?.isArchived).toBe(true);
-            expect(archived?.status).toBe('done');
-        });
+            expect(sessionWorkspacePosts).toContain('workspace-invite');
+        }, { timeout: 2500 });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceId).toBe('workspace-invite');
+        }, { timeout: 2500 });
     });
-    it('preserves an explicit local api base url instead of letting runtime-config reset it to the app origin', async () => {
-        vi.stubGlobal('fetch', vi.fn((url) => {
+    it('rehydrates taxonomy state after retryBootstrapChecks resolves a transient empty cloud taxonomy response', async () => {
+        let taxonomyReady = false;
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
                 return jsonResponse({
                     config: {
-                        runtimeMode: 'local',
-                        workspaceMode: 'single-local',
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
                         authSource: 'cloud',
-                        baseUrl: 'http://localhost:5174',
-                        apiBaseUrl: 'http://localhost:5174',
-                        cloudAuthBaseUrl: 'http://localhost:5174'
+                        workspaceSwitchingEnabled: true
                     }
                 });
             }
-            if (url.includes('/api/taskforce/ui-state?key=app')) {
-                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
             }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
             if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
                 return jsonResponse({
                     success: true,
                     state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
                 });
             }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST') {
+                    return jsonResponse({ success: true });
+                }
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: 'workspace-cloud-1',
+                    workspaces: [{ id: 'workspace-cloud-1', name: 'Cloud Workspace', role: 'owner' }]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace'))
+                return jsonResponse({ success: true });
             if (url.includes('/api/taskforce/config')) {
                 return jsonResponse({
-                    projectName: 'Test Project',
-                    workspaceId: 'workspace-local-active',
-                    runtimeMode: 'local',
+                    projectName: 'Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
                     setupState: {
                         globalSetupState: 'complete',
                         workspaceSetupState: 'complete',
-                        workspaceId: 'workspace-local-active'
+                        workspaceId: 'workspace-cloud-1'
                     }
                 });
             }
-            if (url.includes('/api/taskforce/global-settings')) {
-                return jsonResponse({});
-            }
-            if (url.includes('/api/taskforce/categories')) {
-                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
-            }
-            if (url.includes('/api/taskforce/types')) {
-                return jsonResponse({ types: [] });
-            }
-            if (url.includes('/api/taskforce/priorities')) {
-                return jsonResponse({ priorities: [] });
-            }
-            if (url.includes('/api/taskforce/approaches')) {
-                return jsonResponse({ approaches: [] });
-            }
-            if (url.includes('/api/taskforce/specialists')) {
-                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse(taxonomyReady ? {
+                    categories: [{ value: 'cloud-ops', label: 'Cloud Ops' }],
+                    types: [{ value: 'incident', label: 'Incident' }],
+                    priorities: [{ value: 4, label: 'Critical' }],
+                    taxonomies: []
+                } : {
+                    categories: [],
+                    types: [],
+                    priorities: [],
+                    taxonomies: []
+                });
             }
-            if (url.includes('/api/taskforce/tasks')) {
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap'))
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            if (url.includes('/api/taskforce/tasks'))
                 return jsonResponse({ tasks: [activeTask] });
-            }
-            if (url.includes('/api/taskforce/archive')) {
+            if (url.includes('/api/taskforce/archive'))
                 return jsonResponse({ archived: [] });
-            }
-            if (url.includes('/api/taskforce/data-version')) {
+            if (url.includes('/api/taskforce/data-version'))
                 return jsonResponse({ dataVersion: 1 });
-            }
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
             return jsonResponse({});
         }));
-        const { result } = renderHook(() => useTaskforce({ config: { apiBaseUrl: 'http://127.0.0.1:4280' } }), { wrapper });
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
         await waitFor(() => {
-            expect(result.current.config.apiBaseUrl).toBe('http://127.0.0.1:4280');
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+        }, { timeout: 2500 });
+        expect(result.current.activeCategories.some((category) => category.value === 'cloud-ops')).toBe(false);
+        taxonomyReady = true;
+        await act(async () => {
+            await result.current.retryBootstrapChecks();
         });
+        await waitFor(() => {
+            expect(result.current.activeCategories.some((category) => category.value === 'cloud-ops')).toBe(true);
+            expect(result.current.activeTypes.some((type) => type.value === 'incident')).toBe(true);
+            expect(result.current.priorities.some((priority) => priority.value === 4)).toBe(true);
+        }, { timeout: 2500 });
     });
-    it('opens archived tasks by id and enables archive view', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const archivedChildren = [
-            archivedTaskRecord('task-archived-child-1', 'Archived Task 1')
-        ];
-        vi.stubGlobal('fetch', vi.fn((url) => {
+    it('does not refetch assignee options during retryBootstrapChecks when they are already loaded', async () => {
+        let taxonomyReady = false;
+        const requestOrder = [];
+        vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
                 return jsonResponse({
                     config: {
@@ -592,22 +2726,31 @@ describe('useTaskforce sync behavior', () => {
                     workspaceId: 'workspace-cloud-1'
                 });
             }
-            if (url.includes('/api/taskforce/ui-state?key=app')) {
+            if (url.includes('/api/taskforce/ui-state?key=app'))
                 return jsonResponse({ success: true, state: {} });
-            }
             if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
                 return jsonResponse({
                     success: true,
                     state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
                 });
             }
+            if (url.includes('/api/taskforce/workspaces')) {
+                if (String(init?.method || 'GET').toUpperCase() === 'POST')
+                    return jsonResponse({ success: true });
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: 'workspace-cloud-1',
+                    workspaces: [{ id: 'workspace-cloud-1', name: 'Cloud Workspace', role: 'owner' }]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace'))
+                return jsonResponse({ success: true });
             if (url.includes('/api/taskforce/config')) {
                 return jsonResponse({
                     projectName: 'Cloud Project',
                     workspaceId: 'workspace-cloud-1',
                     runtimeMode: 'cloud',
                     authRequiredForApi: true,
-                    realtimeSyncEnabled: true,
                     userId: 'user-1',
                     setupState: {
                         globalSetupState: 'complete',
@@ -616,38 +2759,58 @@ describe('useTaskforce sync behavior', () => {
                     }
                 });
             }
+            if (url.includes('/api/taskforce/taxonomy-state')) {
+                return jsonResponse(taxonomyReady ? {
+                    categories: [{ value: 'cloud-ops', label: 'Cloud Ops' }],
+                    types: [{ value: 'incident', label: 'Incident' }],
+                    priorities: [{ value: 4, label: 'Critical' }],
+                    taxonomies: []
+                } : {
+                    categories: [],
+                    types: [],
+                    priorities: [],
+                    taxonomies: []
+                });
+            }
             if (url.includes('/api/taskforce/global-settings'))
                 return jsonResponse({});
-            if (url.includes('/api/taskforce/categories'))
-                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
-            if (url.includes('/api/taskforce/types'))
-                return jsonResponse({ types: [] });
-            if (url.includes('/api/taskforce/priorities'))
-                return jsonResponse({ priorities: [] });
-            if (url.includes('/api/taskforce/approaches'))
-                return jsonResponse({ approaches: [] });
-            if (url.includes('/api/taskforce/specialists'))
-                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options')) {
+                requestOrder.push('assignee');
+                return jsonResponse({ assignees: [] });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                requestOrder.push('planning');
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            }
             if (url.includes('/api/taskforce/tasks'))
                 return jsonResponse({ tasks: [activeTask] });
             if (url.includes('/api/taskforce/archive'))
-                return jsonResponse({ archived: archivedChildren });
+                return jsonResponse({ archived: [] });
             if (url.includes('/api/taskforce/data-version'))
                 return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
             return jsonResponse({});
         }));
         const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
         await waitFor(() => {
-            expect(result.current.archivedTasks.some((task) => task.id === 'task-archived-child-1')).toBe(true);
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
         }, { timeout: 2500 });
-        act(() => {
-            result.current.handleOpenTaskById('task-archived-child-1');
-        });
         await waitFor(() => {
-            expect(result.current.showArchive).toBe(true);
-            expect(result.current.editingTaskId).toBe('task-archived-child-1');
-            expect(result.current.currentTask?.isArchived).toBe(true);
+            expect(requestOrder.filter((entry) => entry === 'assignee')).toHaveLength(1);
+        }, { timeout: 2500 });
+        taxonomyReady = true;
+        requestOrder.length = 0;
+        await act(async () => {
+            await result.current.retryBootstrapChecks();
         });
+        await waitFor(() => {
+            expect(result.current.activeCategories.some((category) => category.value === 'cloud-ops')).toBe(true);
+            expect(requestOrder).toContain('planning');
+        }, { timeout: 2500 });
+        expect(requestOrder).not.toContain('assignee');
     });
     it('hydrates merged human members and workspace ai assignees for a signed-in local workspace', async () => {
         vi.stubGlobal('fetch', vi.fn((url) => {
@@ -668,6 +2831,7 @@ describe('useTaskforce sync behavior', () => {
                     betaAccess: true,
                     userId: 'user-1',
                     email: 'user@example.com',
+                    avatarUrl: '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Fheadshot.webp',
                     workspaceId: 'workspace-cloud-1'
                 });
             }
@@ -745,6 +2909,10 @@ describe('useTaskforce sync behavior', () => {
         const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
         await waitFor(() => {
             expect(result.current.assigneeOptions.some((option) => option.value === 'member-1' && option.label === 'Member One')).toBe(true);
+            expect(result.current.assigneeOptions.find((option) => option.value === 'user-1')).toEqual(expect.objectContaining({
+                label: 'Signed In Owner',
+                avatarUrl: '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Fheadshot.webp'
+            }));
             expect(result.current.assigneeOptions.some((option) => option.value === 'ai-profile-codex' && option.label === 'Codex')).toBe(true);
             expect(result.current.currentWorkspaceRole).toBe('owner');
         });
@@ -1097,6 +3265,84 @@ describe('useTaskforce sync behavior', () => {
             expect(result.current.authSessionResolved).toBe(true);
         });
     });
+    it('keeps loopback cloud runtime auth on same-origin after runtime config resolves', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.startsWith('https://app.taskforcehq.ai/api/taskforce/auth/session')) {
+                return jsonResponse({ authenticated: false, authRequiredForApi: true }, 401);
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Loopback Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://app.taskforcehq.ai' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.authSessionResolved).toBe(true);
+            expect(result.current.isAuthenticated).toBe(true);
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+        });
+        expect(fetchMock.mock.calls.some(([url]) => String(url).startsWith('https://app.taskforcehq.ai/api/taskforce/auth/session'))).toBe(false);
+    });
     it('enables cloud realtime refresh for authenticated sessions and refreshes open task comments from signals', async () => {
         vi.stubGlobal('WebSocket', MockWebSocket);
         let invalidationTaskFetchCount = 0;