@taskforcehq/taskforce 0.3.311 → 0.3.313

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

@@ -1,3644 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { MemoryRouter } from 'react-router-dom';
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { useTaskforce } from './useTaskforce';
-class MockWebSocket {
-    static instances = [];
-    static OPEN = 1;
-    static CLOSED = 3;
-    url;
-    readyState = 0;
-    sent = [];
-    listeners = {
-        open: [],
-        message: [],
-        close: [],
-        error: []
-    };
-    constructor(url) {
-        this.url = url;
-        MockWebSocket.instances.push(this);
-    }
-    addEventListener(type, listener) {
-        this.listeners[type] = this.listeners[type] || [];
-        this.listeners[type].push(listener);
-    }
-    close() {
-        this.readyState = MockWebSocket.CLOSED;
-        this.emit('close', {});
-    }
-    send(payload) {
-        this.sent.push(payload);
-    }
-    emit(type, event) {
-        const handlers = this.listeners[type] || [];
-        handlers.forEach((handler) => handler(event));
-    }
-    open() {
-        this.readyState = MockWebSocket.OPEN;
-        this.emit('open', {});
-    }
-    message(payload) {
-        this.emit('message', { data: JSON.stringify(payload) });
-    }
-}
-function jsonResponse(body, status = 200) {
-    return Promise.resolve({
-        ok: status >= 200 && status < 300,
-        status,
-        json: () => Promise.resolve(body)
-    });
-}
-const wrapper = ({ children }) => (_jsx(MemoryRouter, { children: children }));
-const activeTask = {
-    id: 'task-parent',
-    title: 'Parent task',
-    description: 'Parent description',
-    category: 'general',
-    type: 'feature',
-    priority: 2,
-    complexity: 3,
-    status: 'task',
-    createdAt: '2026-03-15T10:00:00.000Z',
-    updatedAt: '2026-03-15T10:00:00.000Z'
-};
-const doneTask = {
-    ...activeTask,
-    id: 'task-done',
-    title: 'Done task',
-    status: 'done',
-    completedAt: '2026-03-15T10:15:00.000Z',
-    updatedAt: '2026-03-15T10:15:00.000Z'
-};
-const archivedTaskRecord = (id, title) => ({
-    id,
-    title,
-    description: `${title} description`,
-    category: 'general',
-    type: 'feature',
-    priority: 2,
-    complexity: 3,
-    status: 'done',
-    createdAt: '2026-03-15T10:10:00.000Z',
-    updatedAt: '2026-03-15T10:10:00.000Z',
-    isArchived: true
-});
-describe('useTaskforce sync behavior', () => {
-    beforeEach(() => {
-        localStorage.clear();
-        sessionStorage.clear();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-        vi.clearAllMocks();
-        MockWebSocket.instances = [];
-    });
-    it('merges a server-returned task into the active collection immediately', 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/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({
-                    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-child') && String(init?.method || '').toUpperCase() === 'PATCH') {
-                return jsonResponse({
-                    id: 'task-child',
-                    title: 'Updated task',
-                    description: 'Updated description',
-                    category: 'general',
-                    type: 'feature',
-                    priority: 2,
-                    complexity: 3,
-                    status: 'in-progress',
-                    createdAt: '2026-03-15T10:05:00.000Z',
-                    updatedAt: '2026-03-15T10:06: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.handleUpdateTask('task-child', { status: 'in-progress' });
-        });
-        await waitFor(() => {
-            const childTask = result.current.tasks.find((task) => task.id === 'task-child');
-            expect(childTask?.status).toBe('in-progress');
-        });
-    });
-    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' } });
-            }
-            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({
-                    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/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({});
-        }));
-        const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
-        await waitFor(() => {
-            expect(result.current.tasks.some((task) => task.id === activeTask.id)).toBe(true);
-        });
-        await act(async () => {
-            await result.current.createWorkstream({
-                title: createdWorkstream.title,
-                description: createdWorkstream.description,
-                initiativeId: createdWorkstream.initiativeId
-            });
-        });
-        await waitFor(() => {
-            expect(result.current.workstreams.some((workstream) => workstream.id === createdWorkstream.id)).toBe(true);
-        });
-    });
-    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/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({
-                    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/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 === activeTask.id)).toBe(true);
-        });
-        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: 3000 });
-    });
-    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/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({
-                    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/planning/bootstrap')) {
-                planningBootstrapCalls += 1;
-                if (planningBootstrapCalls === 1) {
-                    return Promise.reject(new Error('temporary failure'));
-                }
-                return jsonResponse({
-                    initiatives: [initiative],
-                    workstreams: [workstream],
-                    workstreamTaskSummaries: [],
-                });
-            }
-            if (url.includes('/api/taskforce/data-version'))
-                return jsonResponse({ dataVersion: 1 });
-            return jsonResponse({});
-        }));
-        const { result } = renderHook(() => useTaskforce({ config: {} }), { wrapper });
-        await waitFor(() => {
-            expect(planningBootstrapCalls).toBeGreaterThanOrEqual(1);
-        });
-        await waitFor(() => {
-            expect(result.current.tasks.some((task) => task.id === activeTask.id)).toBe(true);
-        });
-        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('retries a timed-out planning bootstrap without falling back to legacy endpoints during startup', async () => {
-        const initiative = {
-            id: 'initiative-timeout-1',
-            title: 'Timeout initiative',
-            description: null,
-            createdAt: '2026-03-15T10:00:00.000Z',
-        };
-        const workstream = {
-            id: 'workstream-timeout-1',
-            title: 'Timeout workstream',
-            description: null,
-            initiativeId: initiative.id,
-            createdAt: '2026-03-15T10:05:00.000Z',
-        };
-        let planningBootstrapCalls = 0;
-        let initiativesCalls = 0;
-        let workstreamsCalls = 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/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({
-                    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/planning/bootstrap')) {
-                planningBootstrapCalls += 1;
-                if (planningBootstrapCalls === 1) {
-                    return Promise.reject(new DOMException('timed out', 'AbortError'));
-                }
-                return jsonResponse({
-                    initiatives: [initiative],
-                    workstreams: [workstream],
-                    workstreamTaskSummaries: [],
-                });
-            }
-            if (url.includes('/api/taskforce/initiatives')) {
-                initiativesCalls += 1;
-                return jsonResponse([initiative]);
-            }
-            if (url.includes('/api/taskforce/workstreams')) {
-                workstreamsCalls += 1;
-                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 === activeTask.id)).toBe(true);
-        });
-        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 });
-        expect(planningBootstrapCalls).toBeGreaterThanOrEqual(2);
-        expect(initiativesCalls).toBe(0);
-        expect(workstreamsCalls).toBe(0);
-    }, 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: 'cloud',
-                        workspaceMode: 'single-cloud',
-                        authSource: 'cloud',
-                        workspaceSwitchingEnabled: false
-                    }
-                });
-            }
-            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,
-                    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'))
-                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/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/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,
-                    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/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/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: { 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 accepted = await result.current.acceptInviteWithToken('invite-token', 'NewUserPass123!');
-            expect(accepted).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('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: '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(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/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-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('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: {
-                        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(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/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: [] });
-            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-cloud-1');
-        }, { timeout: 2500 });
-        await waitFor(() => {
-            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) => {
-            if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({
-                    config: {
-                        runtimeMode: 'local',
-                        workspaceMode: 'single-local',
-                        authSource: 'cloud',
-                        workspaceSwitchingEnabled: false
-                    }
-                });
-            }
-            if (url.includes('/api/taskforce/auth/session')) {
-                return jsonResponse({
-                    authenticated: true,
-                    authRequiredForApi: true,
-                    betaAccess: true,
-                    userId: 'user-1',
-                    email: 'user@example.com',
-                    avatarUrl: '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Fheadshot.webp',
-                    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,
-                    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/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/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: [
-                        { value: 'ai-profile-codex', label: 'Codex', icon: 'Bot', color: '#0ea5e9', kind: 'agent' }
-                    ]
-                });
-            }
-            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.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');
-        });
-    });
-    it('keeps human assignees unavailable while signed out locally but still loads ai assignees', 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',
-                        workspaceSwitchingEnabled: false
-                    }
-                });
-            }
-            if (url.includes('/api/taskforce/auth/session')) {
-                return jsonResponse({
-                    authenticated: false,
-                    authRequiredForApi: true,
-                    betaAccess: false,
-                    userId: 'anonymous',
-                    email: '',
-                    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: 'Local Project',
-                    workspaceId: 'workspace-cloud-1',
-                    runtimeMode: 'local',
-                    authRequiredForApi: true,
-                    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: [
-                        { value: 'ai-profile-codex', label: 'Codex', icon: 'Bot', color: '#0ea5e9', kind: 'agent' }
-                    ]
-                });
-            }
-            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.assigneeOptions.some((option) => option.value === 'ai-profile-codex' && option.label === 'Codex')).toBe(true);
-            expect(result.current.assigneeOptions.some((option) => option.kind === 'member')).toBe(false);
-            expect(result.current.currentWorkspaceRole).toBeNull();
-        });
-    });
-    it('keeps fallback human assignees when workspace-members only returns the signed-in user', async () => {
-        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: 'member-self',
-                    email: 'self@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,
-                    userId: 'member-self',
-                    setupState: {
-                        globalSetupState: 'complete',
-                        workspaceSetupState: 'complete',
-                        workspaceId: 'workspace-cloud-1'
-                    }
-                });
-            }
-            if (url.includes('/api/taskforce/global-settings'))
-                return jsonResponse({});
-            if (url.includes('/api/taskforce/auth/workspace-members')) {
-                return jsonResponse({
-                    users: [
-                        {
-                            userId: 'member-self',
-                            email: 'self@example.com',
-                            displayName: 'Self User',
-                            status: 'active',
-                            disabled: false
-                        }
-                    ]
-                });
-            }
-            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: [
-                        { userId: 'member-self', email: 'self@example.com', displayName: 'Self User', status: 'active', disabled: false },
-                        { userId: 'member-2', email: 'member2@example.com', displayName: 'Member Two', status: 'active', disabled: false },
-                        { value: 'ai-profile-codex', label: 'Codex', icon: 'Bot', color: '#0ea5e9', kind: 'agent' }
-                    ]
-                });
-            }
-            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.assigneeOptions.some((option) => option.value === 'member-self' && option.label === 'Self User')).toBe(true);
-            expect(result.current.assigneeOptions.some((option) => option.value === 'member-2' && option.label === 'Member Two')).toBe(true);
-            expect(result.current.assigneeOptions.some((option) => option.value === 'ai-profile-codex' && option.label === 'Codex')).toBe(true);
-        });
-    });
-    it('keeps the local hydrated workspace role when workspace-members temporarily fails', async () => {
-        let workspaceMembersCalls = 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',
-                        workspaceSwitchingEnabled: false
-                    }
-                });
-            }
-            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: 'Local Project',
-                    workspaceId: 'workspace-cloud-1',
-                    runtimeMode: 'local',
-                    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: [
-                        { value: 'member-1', label: 'Member One', icon: 'User', color: '#22c55e', kind: 'member', userId: 'member-1', email: 'member1@example.com' }
-                    ]
-                });
-            }
-            if (url.includes('/api/taskforce/auth/workspace-members')) {
-                workspaceMembersCalls += 1;
-                if (workspaceMembersCalls === 1) {
-                    return jsonResponse({
-                        users: [
-                            {
-                                userId: 'user-1',
-                                email: 'user@example.com',
-                                displayName: 'Signed In Owner',
-                                role: 'owner',
-                                status: 'active',
-                                disabled: false
-                            }
-                        ]
-                    });
-                }
-                return Promise.reject(new Error('temporary workspace-members failure'));
-            }
-            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.currentWorkspaceRole).toBe('owner');
-        });
-        await act(async () => {
-            await result.current.fetchAssigneeOptions();
-        });
-        expect(result.current.currentWorkspaceRole).toBe('owner');
-    });
-    it('seeds local auth state from the persisted loopback actor while localhost session bootstrap is in flight', async () => {
-        sessionStorage.setItem('taskforce.localMutationActorUserId.v1', 'user-1');
-        const fetchMock = vi.fn((url) => {
-            if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({
-                    config: {
-                        runtimeMode: 'local',
-                        workspaceMode: 'single-local',
-                        authSource: 'cloud',
-                        workspaceSwitchingEnabled: false,
-                        cloudAuthBaseUrl: 'https://app.taskforcehq.ai',
-                        cloudAuthViaLocalProxy: 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: 'Local Project',
-                    workspaceId: 'workspace-cloud-1',
-                    runtimeMode: 'local',
-                    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 });
-        expect(result.current.isAuthenticated).toBe(true);
-        expect(result.current.authSessionResolved).toBe(true);
-        await waitFor(() => {
-            expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/auth/session'))).toBe(true);
-        });
-        await waitFor(() => {
-            expect(result.current.isAuthenticated).toBe(true);
-            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;
-        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,
-                        wsBaseUrl: '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: '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,
-                    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')) {
-                const serveUpdatedTask = invalidationTaskFetchCount >= 2;
-                if (invalidationTaskFetchCount > 0) {
-                    invalidationTaskFetchCount += 1;
-                }
-                const updatedAt = serveUpdatedTask ? '2026-03-16T10:05:00.000Z' : '2026-03-16T10:00:00.000Z';
-                const comments = serveUpdatedTask
-                    ? [{ id: 'comment-2', author: 'user', text: 'Fresh synced comment', timestamp: '2026-03-16T10:05:00.000Z' }]
-                    : [{ id: 'comment-1', author: 'user', text: 'Initial comment', timestamp: '2026-03-16T10:00:00.000Z' }];
-                return jsonResponse({
-                    tasks: [{
-                            ...activeTask,
-                            updatedAt,
-                            comments
-                        }]
-                });
-            }
-            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: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
-        await waitFor(() => {
-            expect(result.current.tasks).toHaveLength(1);
-        });
-        await waitFor(() => {
-            expect(result.current.authSessionResolved).toBe(true);
-            expect(result.current.isAuthenticated).toBe(true);
-            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
-            expect(MockWebSocket.instances).toHaveLength(1);
-        });
-        const socket = MockWebSocket.instances[0];
-        act(() => {
-            socket.open();
-            result.current.handleEdit(result.current.tasks[0]);
-        });
-        await waitFor(() => {
-            expect(result.current.comments).toEqual([
-                { id: 'comment-1', author: 'user', text: 'Initial comment', timestamp: '2026-03-16T10:00:00.000Z' }
-            ]);
-        });
-        act(() => {
-            result.current.setNewCommentText('Unsaved draft');
-            invalidationTaskFetchCount = 1;
-            socket.message({ type: 'taskforce:update', workspaceId: 'workspace-cloud-1' });
-        });
-        await waitFor(() => {
-            expect(result.current.comments).toEqual([
-                { id: 'comment-1', author: 'user', text: 'Initial comment', timestamp: '2026-03-16T10:00:00.000Z' }
-            ]);
-        });
-        await act(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 350));
-        });
-        await waitFor(() => {
-            expect(result.current.comments).toEqual([
-                { id: 'comment-2', author: 'user', text: 'Fresh synced comment', timestamp: '2026-03-16T10:05:00.000Z' }
-            ]);
-            expect(result.current.currentTask?.updatedAt).toBe('2026-03-16T10:05:00.000Z');
-            expect(result.current.newCommentText).toBe('Unsaved draft');
-        });
-        const taskFetches = fetchMock.mock.calls.filter(([url]) => String(url).includes('/api/taskforce/tasks'));
-        expect(taskFetches.length).toBeGreaterThanOrEqual(3);
-    });
-    it('does not start cloud realtime before auth session resolves with a real user id', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        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,
-                        wsBaseUrl: 'https://cloud.example.com'
-                    }
-                });
-            }
-            if (url.includes('/api/taskforce/auth/session')) {
-                return jsonResponse({
-                    authenticated: false,
-                    authRequiredForApi: true,
-                    betaAccess: true,
-                    userId: 'anonymous',
-                    email: '',
-                    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: 'anonymous',
-                    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/data-version'))
-                return jsonResponse({ dataVersion: 1 });
-            return jsonResponse({});
-        }));
-        renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
-        await waitFor(() => {
-            expect(MockWebSocket.instances).toHaveLength(0);
-        });
-    });
-});