@taskforcehq/taskforce 0.3.170 → 0.3.300

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

@@ -0,0 +1,1120 @@
+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();
+    });
+    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: 'local' } });
+            }
+            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 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: 'local' } });
+            }
+            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: 'local' } });
+            }
+            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: 'local' } });
+            }
+            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: 'local' } });
+            }
+            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: 'local',
+                        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 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',
+                    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.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('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);
+        });
+    });
+});