@taskforcehq/taskforce 0.3.168

package/dist/TaskforceCore.test.js

@@ -0,0 +1,2132 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MemoryRouter } from 'react-router-dom';
+import { TaskforceCore } from './TaskforceCore';
+import fs from 'fs';
+import path from 'path';
+const mockTasks = [
+    {
+        id: 'task-20260130-abc123',
+        title: 'Integration Task 1',
+        description: 'Testing core',
+        category: 'general',
+        type: 'feature',
+        priority: 2,
+        createdAt: new Date().toISOString(),
+        completed: false,
+        status: 'task'
+    }
+];
+const mockConfig = {
+    storagePath: '.Taskforce',
+    shortcut: 'Alt+T',
+    projectName: 'Test Project',
+    setupState: {
+        globalSetupState: 'complete',
+        workspaceSetupState: 'complete',
+        workspaceId: 'default'
+    }
+};
+const mockCategories = {
+    categories: [{ value: 'general', label: 'General' }]
+};
+describe('TaskforceCore Integration', () => {
+    beforeEach(() => {
+        localStorage.clear();
+        vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockConfig) });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        }));
+    });
+    it('5.1 & 5.3 Renders main header and task list', async () => {
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        // Header check
+        expect(screen.getByText('TaskForce')).toBeInTheDocument();
+        // Wait for tasks to load and render
+        await waitFor(() => {
+            // Check project name
+            expect(screen.getByText('Test Project')).toBeInTheDocument();
+            expect(screen.getByText('1/1')).toBeInTheDocument();
+        });
+    });
+    it('5.2 Does not render the widget floating button', async () => {
+        const { container } = render(_jsx(TaskforceCore, {}));
+        expect(screen.queryByTitle('Open Taskforce')).not.toBeInTheDocument();
+        // Core should have its standalone main container
+        await waitFor(() => {
+            const root = container.querySelector('[class*="standaloneWrapper"]');
+            expect(root).toBeInTheDocument();
+        });
+    });
+    it('5.3 Calls onTaskCountChange with task count', async () => {
+        const onCountChange = vi.fn();
+        render(_jsx(TaskforceCore, { onTaskCountChange: onCountChange }));
+        await waitFor(() => {
+            expect(onCountChange).toHaveBeenCalledWith(1);
+        });
+    });
+    it('5.7 Deep Link: Opens specific task when short ID is provided', async () => {
+        render(_jsx(TaskforceCore, { initialTaskId: "abc123" }));
+        await waitFor(() => {
+            // Should be in Edit mode (Update button visible)
+            expect(screen.getByText('Update')).toBeInTheDocument();
+            // Form should have the title
+            expect(screen.getByDisplayValue('Integration Task 1')).toBeInTheDocument();
+        });
+    });
+    it('Navigation: Can switch to Settings', async () => {
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+    });
+    it.skip('migrates legacy saved priority filters across active, archive, and kanban visibility', async () => {
+        const user = userEvent.setup();
+        const activeTasks = [
+            {
+                id: 'task-20260210-pri1',
+                title: 'Priority One Active',
+                description: null,
+                category: 'general',
+                type: 'feature',
+                priority: 1,
+                createdAt: new Date().toISOString(),
+                completed: false,
+                status: 'task'
+            },
+            {
+                id: 'task-20260210-pri2',
+                title: 'Priority Two Active',
+                description: null,
+                category: 'general',
+                type: 'feature',
+                priority: 2,
+                createdAt: new Date().toISOString(),
+                completed: false,
+                status: 'task'
+            }
+        ];
+        const archivedTasks = [
+            {
+                id: 'task-20260210-pri3-archived',
+                title: 'Priority Three Archived',
+                description: null,
+                category: 'general',
+                type: 'feature',
+                priority: 3,
+                createdAt: new Date().toISOString(),
+                completed: true,
+                status: 'done'
+            }
+        ];
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockConfig) });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        categories: [{ value: 'general', label: 'General' }]
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: activeTasks }) });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: archivedTasks }) });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        priorities: [
+                            { value: 1, label: 'P1' },
+                            { value: 2, label: 'P2' },
+                            { value: 3, label: 'P3' },
+                            { value: 4, label: 'P4' }
+                        ]
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [{ value: 'feature', label: 'Feature' }] }) });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            hasInitedFilters: true,
+                            filterPriorities: ['1', '3'],
+                            filterCategories: ['general'],
+                            filterTypes: ['feature'],
+                            filterStatus: ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled'],
+                            groupBy: 'priority'
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
+        await waitFor(() => {
+            expect(screen.getByText('Priority One Active')).toBeInTheDocument();
+        });
+        expect(screen.queryByText('Priority Two Active')).not.toBeInTheDocument();
+        await waitFor(() => {
+            expect(screen.getByTitle('Add task to P1')).toBeInTheDocument();
+            expect(screen.getByTitle('Add task to P3')).toBeInTheDocument();
+        });
+        expect(screen.queryByTitle('Add task to P2')).not.toBeInTheDocument();
+        await user.click(screen.getByTitle('Toggle Filters'));
+        await user.click(screen.getByRole('checkbox', { name: /include archive/i }));
+        await waitFor(() => {
+            expect(screen.getByText(/Priority Three Archived/)).toBeInTheDocument();
+        });
+        expect(fetchMock.mock.calls.some((call) => call[0] === '/api/taskforce/archive')).toBe(true);
+    });
+    it('shows full-page login when cloud auth is required and user is unauthenticated', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: false,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            workspaceId: 'default',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'cloud',
+                            supportsCloudAuth: true,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: false
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: false, status: 401, json: () => Promise.resolve({ error: 'Unauthorized' }) });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { container } = render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByPlaceholderText('Email')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Sign In' })).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Register' })).toBeInTheDocument();
+            expect(screen.queryByRole('button', { name: 'Create Account' })).not.toBeInTheDocument();
+            expect(screen.queryByRole('button', { name: 'Close sign in' })).not.toBeInTheDocument();
+        });
+        expect(container.querySelector('[aria-pressed]')).not.toBeInTheDocument();
+    });
+    it('shows updated setup-bootstrap copy while startup checks are in progress', async () => {
+        const hangingConfig = new Promise(() => { });
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/config')) {
+                return hangingConfig;
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/setup?step=workspace'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Loading Taskforce')).toBeInTheDocument();
+            expect(screen.getByText(/Verifying session|Checking account, workspace access, and setup status/)).toBeInTheDocument();
+        });
+        expect(screen.queryByText('Loading Setup')).not.toBeInTheDocument();
+    });
+    it('keeps account menu in bootstrap-pending state until runtime config resolves, then shows signed-in identity immediately', async () => {
+        const user = userEvent.setup();
+        let resolveRuntimeConfig = null;
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return new Promise((resolve) => {
+                    resolveRuntimeConfig = resolve;
+                });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        email: 'member@example.com',
+                        userId: 'user-member',
+                        workspaceId: 'workspace-local-active',
+                        betaAccess: true
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active',
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'local',
+                            workspaceId: 'workspace-local-active',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        expect(screen.getByText('Checking sign-in status...')).toBeInTheDocument();
+        expect(screen.queryByText('Sign In / Register')).not.toBeInTheDocument();
+        if (resolveRuntimeConfig) {
+            resolveRuntimeConfig({
+                ok: true,
+                json: () => Promise.resolve({
+                    success: true,
+                    config: {
+                        baseUrl: 'https://cloud.example.com',
+                        apiBaseUrl: 'https://cloud.example.com',
+                        cloudAuthBaseUrl: 'https://cloud.example.com',
+                        wsBaseUrl: null,
+                        runtimeMode: 'local'
+                    }
+                })
+            });
+        }
+        await waitFor(() => {
+            expect(screen.getByText(/Signed in as/i)).toBeInTheDocument();
+            expect(screen.getByText('member@example.com')).toBeInTheDocument();
+        });
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/workspaces'))).toBe(false);
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/session/workspace'))).toBe(false);
+    });
+    it('allows local runtime to open shared /login and register flow', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: false,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'local',
+                            workspaceId: 'workspace-local-active',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { container } = render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Create your Taskforce account.')).toBeInTheDocument();
+            expect(screen.getByPlaceholderText('Email')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Create Account' })).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Sign In' })).toBeInTheDocument();
+            expect(screen.queryByRole('button', { name: 'Register' })).not.toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Close sign in' })).toBeInTheDocument();
+        });
+        expect(container.querySelector('[aria-pressed]')).not.toBeInTheDocument();
+    });
+    it('allows returning to sign-in/register from forgot mode', async () => {
+        const user = userEvent.setup();
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: false,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'local',
+                            workspaceId: 'workspace-local-active',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=forgot&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Request a password reset link.')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Sign In' })).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Register' })).toBeInTheDocument();
+            expect(screen.queryByRole('button', { name: 'Accept Invite' })).not.toBeInTheDocument();
+            expect(screen.queryByRole('button', { name: /Resend Verification/ })).not.toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('button', { name: 'Sign In' }));
+        await waitFor(() => {
+            expect(screen.getByText('Sign in with your account credentials.')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Register' })).toBeInTheDocument();
+        });
+    });
+    it('shows global setup route when forced and persists selected mode', async () => {
+        const user = userEvent.setup();
+        let selectedMode = null;
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                const mode = selectedMode;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        setupState: {
+                            globalSetupState: mode ? 'present' : 'missing',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'local',
+                            workspaceId: 'default',
+                            mode: mode || 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: true,
+                            forceWorkspaceSetup: false
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'local',
+                            supportsCloudAuth: false,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: true
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                selectedMode = body?.setup?.mode === 'operations' ? 'operations' : 'core';
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Global Setup Required')).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('radio', { name: /operations mode/i }));
+        await user.click(screen.getByRole('button', { name: 'Save Global Setup' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        expect(fetchMock).toHaveBeenCalledWith('/api/taskforce/global-settings', expect.objectContaining({ method: 'POST' }));
+    });
+    it('shows workspace setup route when required and persists workspace profile', async () => {
+        const user = userEvent.setup();
+        let workspaceSaved = false;
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
+                            runtimeMode: 'local',
+                            workspaceId: 'default',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: true,
+                            workspace: workspaceSaved ? { id: 'default', slug: 'default', name: 'Delta Project', description: 'Workspace desc' } : null,
+                            suggestedWorkspaceName: 'Suggested Project'
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'local',
+                            supportsCloudAuth: false,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: true
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workspace-profile')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                if (body?.name === 'Delta Project')
+                    workspaceSaved = true;
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Workspace Setup Required')).toBeInTheDocument();
+        });
+        const nameInput = screen.getByPlaceholderText('Project name');
+        await user.clear(nameInput);
+        await user.type(nameInput, 'Delta Project');
+        await user.type(screen.getByPlaceholderText('Project description (optional)'), 'Workspace desc');
+        await user.click(screen.getByRole('button', { name: 'Save Project Setup' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        expect(fetchMock).toHaveBeenCalledWith('/api/taskforce/workspace-profile', expect.objectContaining({ method: 'POST' }));
+        const workspaceSyncStateCall = fetchMock.mock.calls.find((call) => {
+            if (!String(call[0]).includes('/api/taskforce/ui-state'))
+                return false;
+            const init = call[1];
+            if (String(init?.method || '').toUpperCase() !== 'POST')
+                return false;
+            const body = JSON.parse(String(init?.body || '{}'));
+            return body?.stateKey === 'workspace-sync';
+        });
+        const workspaceSyncStateBody = JSON.parse(String(workspaceSyncStateCall?.[1]?.body || '{}'));
+        expect(workspaceSyncStateBody.stateKey).toBe('workspace-sync');
+        expect(workspaceSyncStateBody.patch?.cloudSyncEnabled).toBe(false);
+    });
+    it('recovers from transient local workspace-missing setup state after scope resolves on refresh', async () => {
+        let configCalls = 0;
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: false,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                configCalls += 1;
+                const firstPass = configCalls === 1;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        projectRoot: '/mock/local-project-refresh',
+                        workspaceId: 'workspace-local-refresh',
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: firstPass ? 'missing' : 'present',
+                            runtimeMode: 'local',
+                            workspaceId: 'workspace-local-refresh',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: firstPass,
+                            workspace: firstPass
+                                ? null
+                                : { id: 'workspace-local-refresh', slug: 'workspace-local-refresh', name: 'Local Refresh Project', description: null },
+                            suggestedWorkspaceName: 'Local Refresh Project'
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'local',
+                            supportsCloudAuth: true,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: true
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(configCalls).toBeGreaterThan(1);
+        });
+        expect(screen.getByRole('button', { name: /add task/i })).toBeInTheDocument();
+        expect(screen.queryByText('Workspace Setup Required')).not.toBeInTheDocument();
+    });
+    it('allows workspace setup to sync from selected cloud project into matching local workspace id', async () => {
+        const user = userEvent.setup();
+        let workspaceSaved = false;
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
+                            runtimeMode: 'local',
+                            workspaceId: workspaceSaved ? 'workspace-cloud-123' : 'default',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: true,
+                            workspace: workspaceSaved
+                                ? { id: 'workspace-cloud-123', slug: 'workspace-cloud-123', name: 'Cloud Project 123', description: 'Cloud desc' }
+                                : null,
+                            suggestedWorkspaceName: 'Suggested Project'
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'local',
+                            supportsCloudAuth: true,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: true
+                        }
+                    })
+                });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/workspaces')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspaces: [
+                            {
+                                id: 'workspace-cloud-123',
+                                name: 'Cloud Project 123',
+                                description: 'Cloud desc'
+                            }
+                        ]
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workspace-profile')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                if (body?.workspaceId === 'workspace-cloud-123')
+                    workspaceSaved = true;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspace: {
+                            id: 'workspace-cloud-123'
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/ui-state')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/setup?step=workspace&source=cloud'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        await waitFor(() => {
+            expect(screen.getByText('Workspace Setup Required')).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('radio', { name: /sync existing cloud project/i }));
+        await waitFor(() => {
+            expect(screen.getByRole('option', { name: /Cloud Project 123/ })).toBeInTheDocument();
+        });
+        await user.selectOptions(screen.getByRole('combobox'), 'workspace-cloud-123');
+        await user.click(screen.getByRole('button', { name: 'Save Project Setup' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        const workspaceProfileCall = fetchMock.mock.calls.find((call) => String(call[0]).includes('/api/taskforce/workspace-profile'));
+        const workspaceProfileBody = JSON.parse(String(workspaceProfileCall?.[1]?.body || '{}'));
+        expect(workspaceProfileBody.workspaceId).toBe('workspace-cloud-123');
+        const workspaceSyncStateCall = fetchMock.mock.calls.find((call) => {
+            if (!String(call[0]).includes('/api/taskforce/ui-state'))
+                return false;
+            const init = call[1];
+            if (String(init?.method || '').toUpperCase() !== 'POST')
+                return false;
+            const body = JSON.parse(String(init?.body || '{}'));
+            return body?.stateKey === 'workspace-sync';
+        });
+        const workspaceSyncStateBody = JSON.parse(String(workspaceSyncStateCall?.[1]?.body || '{}'));
+        expect(workspaceSyncStateBody.stateKey).toBe('workspace-sync');
+        expect(workspaceSyncStateBody.patch?.cloudSyncEnabled).toBe(true);
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('https://cloud.example.com/api/taskforce/workspaces'))).toBe(true);
+    });
+    it('enables workspace cloud sync from local setup when signed in and checkbox is selected', async () => {
+        const user = userEvent.setup();
+        let workspaceSaved = false;
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
+                            runtimeMode: 'local',
+                            workspaceId: workspaceSaved ? 'workspace-local-setup-1' : 'default',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: true,
+                            workspace: workspaceSaved
+                                ? { id: 'workspace-local-setup-1', slug: 'workspace-local-setup-1', name: 'Local Project', description: 'Local desc' }
+                                : null,
+                            suggestedWorkspaceName: 'Suggested Project'
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'local',
+                            supportsCloudAuth: true,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: true
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workspace-profile')) {
+                workspaceSaved = true;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspace: {
+                            id: 'workspace-local-setup-1'
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/setup?step=workspace'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        await waitFor(() => {
+            expect(screen.getByText('Workspace Setup Required')).toBeInTheDocument();
+        });
+        await waitFor(() => {
+            expect(screen.getByRole('checkbox', { name: /sync to cloud after setup/i })).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('checkbox', { name: /sync to cloud after setup/i }));
+        const nameInput = screen.getByPlaceholderText('Project name');
+        await user.clear(nameInput);
+        await user.type(nameInput, 'Local Project');
+        await user.click(screen.getByRole('button', { name: 'Save Project Setup' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        const workspaceSyncStateCall = fetchMock.mock.calls.find((call) => {
+            if (!String(call[0]).includes('/api/taskforce/ui-state'))
+                return false;
+            const req = call[1];
+            if (String(req?.method || '').toUpperCase() !== 'POST')
+                return false;
+            const body = JSON.parse(String(req?.body || '{}'));
+            return body?.stateKey === 'workspace-sync';
+        });
+        const workspaceSyncStateBody = JSON.parse(String(workspaceSyncStateCall?.[1]?.body || '{}'));
+        expect(workspaceSyncStateBody.patch?.cloudSyncEnabled).toBe(true);
+        expect(workspaceSyncStateBody.patch?.sourceOfTruth).toBe('local');
+        // I6: onboarding now starts as false; the orchestrator marks it true after first pull.
+        expect(workspaceSyncStateBody.patch?.onboardingCompleted).toBe(false);
+    });
+    it('completes local first-run setup, survives refresh, and provisions cloud workspace on sync', async () => {
+        const user = userEvent.setup();
+        let workspaceSaved = false;
+        let workspaceSyncState = {
+            cloudSyncEnabled: false,
+            sourceOfTruth: null,
+            onboardingCompleted: false
+        };
+        let cloudWorkspaceCreated = false;
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: workspaceSaved ? 'workspace-local-flow-1' : 'default'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: workspaceSaved ? 'workspace-local-flow-1' : 'default',
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
+                            runtimeMode: 'local',
+                            workspaceId: workspaceSaved ? 'workspace-local-flow-1' : 'default',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: !workspaceSaved,
+                            workspace: workspaceSaved
+                                ? { id: 'workspace-local-flow-1', slug: 'workspace-local-flow-1', name: 'Local Flow Project', description: 'Flow desc' }
+                                : null,
+                            suggestedWorkspaceName: 'Suggested Project'
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'local',
+                            supportsCloudAuth: true,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: true
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workspace-profile')) {
+                workspaceSaved = true;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspace: { id: 'workspace-local-flow-1' }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: workspaceSyncState
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                const body = JSON.parse(String(init?.body || '{}'));
+                if (body?.stateKey === 'workspace-sync' && body?.patch && typeof body.patch === 'object') {
+                    // Merge patch fields only (mirrors server behaviour) so partial patches
+                    // like { onboardingCompleted: true } don't reset cloudSyncEnabled to false.
+                    if (body.patch.cloudSyncEnabled !== undefined)
+                        workspaceSyncState.cloudSyncEnabled = Boolean(body.patch.cloudSyncEnabled);
+                    if (body.patch.sourceOfTruth !== undefined)
+                        workspaceSyncState.sourceOfTruth = (body.patch.sourceOfTruth === 'cloud' || body.patch.sourceOfTruth === 'local') ? body.patch.sourceOfTruth : null;
+                    if (body.patch.onboardingCompleted !== undefined)
+                        workspaceSyncState.onboardingCompleted = Boolean(body.patch.onboardingCompleted);
+                }
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/handshake')) {
+                if (!cloudWorkspaceCreated) {
+                    return Promise.resolve({
+                        ok: false,
+                        status: 409,
+                        json: () => Promise.resolve({
+                            success: false,
+                            code: 'WORKSPACE_ID_MISMATCH',
+                            error: 'Workspace mismatch'
+                        })
+                    });
+                }
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        localWorkspaceId: 'workspace-local-flow-1',
+                        cloudWorkspaceId: 'workspace-local-flow-1'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/provision')) {
+                cloudWorkspaceCreated = true;
+                return Promise.resolve({
+                    ok: true,
+                    status: 201,
+                    json: () => Promise.resolve({
+                        success: true,
+                        existing: false,
+                        workspace: { id: 'workspace-local-flow-1', name: 'Local Flow Project' }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/pull')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspaceId: 'workspace-local-flow-1',
+                        changes: [],
+                        nextCursor: '',
+                        hasMore: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/push')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const initialRender = render(_jsx(MemoryRouter, { initialEntries: ['/setup?step=workspace'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        await waitFor(() => {
+            expect(screen.getByText('Workspace Setup Required')).toBeInTheDocument();
+        });
+        await waitFor(() => {
+            expect(screen.getByRole('checkbox', { name: /sync to cloud after setup/i })).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('checkbox', { name: /sync to cloud after setup/i }));
+        const nameInput = screen.getByPlaceholderText('Project name');
+        await user.clear(nameInput);
+        await user.type(nameInput, 'Local Flow Project');
+        await user.click(screen.getByRole('button', { name: 'Save Project Setup' }));
+        await waitFor(() => {
+            expect(workspaceSaved).toBe(true);
+        });
+        initialRender.unmount();
+        render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        await waitFor(() => {
+            expect(screen.queryByText('Workspace Setup Required')).not.toBeInTheDocument();
+            expect(screen.getByRole('button', { name: /add task/i })).toBeInTheDocument();
+        });
+        expect(cloudWorkspaceCreated).toBe(false);
+    });
+    it('shows local runtime Sign In / Register action and routes to shared login', async () => {
+        const standaloneLayoutPath = path.join(process.cwd(), 'src/components/views/StandaloneLayout.tsx');
+        const standaloneLayoutSource = fs.readFileSync(standaloneLayoutPath, 'utf8');
+        expect(standaloneLayoutSource).toContain('Sign In / Register');
+        expect(standaloneLayoutSource).toContain('openSharedLoginRoute(\'login\')');
+        expect(standaloneLayoutSource).toContain('navigate(`/login?mode=${mode}&next=${encodeURIComponent(target)}`)');
+    });
+    it('uses shared /login flow for local sign in instead of a duplicate modal', async () => {
+        const standaloneLayoutPath = path.join(process.cwd(), 'src/components/views/StandaloneLayout.tsx');
+        const standaloneLayoutSource = fs.readFileSync(standaloneLayoutPath, 'utf8');
+        const useTaskforcePath = path.join(process.cwd(), 'src/hooks/useTaskforce.ts');
+        const useTaskforceSource = fs.readFileSync(useTaskforcePath, 'utf8');
+        expect(standaloneLayoutSource).not.toContain('showCloudSignInModal');
+        expect(standaloneLayoutSource).not.toContain('cloudSignInEmail');
+        expect(useTaskforceSource).toContain("resolveCloudAuthUrl('/api/taskforce/auth/login')");
+        expect(useTaskforceSource).toContain("return { success: false, error: 'Sign in failed.'");
+    });
+    it('does not promote auth state from generic task fetch success', async () => {
+        const useTaskforcePath = path.join(process.cwd(), 'src/hooks/useTaskforce.ts');
+        const useTaskforceSource = fs.readFileSync(useTaskforcePath, 'utf8');
+        // Auth state should be derived from session/login flows, not inferred from /tasks success.
+        expect(useTaskforceSource).not.toContain('setIsAuthenticated(true);');
+    });
+    it('uses production cloud fallback for local runtime auth/sync endpoints', async () => {
+        const useTaskforcePath = path.join(process.cwd(), 'src/hooks/useTaskforce.ts');
+        const useTaskforceSource = fs.readFileSync(useTaskforcePath, 'utf8');
+        const appMainPath = path.join(process.cwd(), 'apps/app/main.tsx');
+        const appMainSource = fs.readFileSync(appMainPath, 'utf8');
+        expect(useTaskforceSource).toContain("return 'https://app.taskforcehq.ai';");
+        expect(appMainSource).toContain('const envBase = String(import.meta.env.VITE_TASKFORCE_BASE_URL || \'\').trim();');
+        expect(appMainSource).toContain('return undefined;');
+    });
+    it('keeps local-only runtime behavior when signed out (no workspace cloud pull calls)', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: false,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/)).toBeInTheDocument();
+        });
+        await waitFor(() => {
+            const uiStateCalls = fetchMock.mock.calls.filter((call) => typeof call[0] === 'string' && String(call[0]).includes('/api/taskforce/ui-state?key=workspace-sync'));
+            expect(uiStateCalls.length).toBeGreaterThan(0);
+        });
+        const pullCalls = fetchMock.mock.calls.filter((call) => typeof call[0] === 'string' && String(call[0]).includes('/sync/workspace/pull'));
+        expect(pullCalls.length).toBe(0);
+    });
+    it('does not pull from cloud when workspace sync toggle is disabled', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: false,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await waitFor(() => {
+            const uiStateCalls = fetchMock.mock.calls.filter((call) => typeof call[0] === 'string' && String(call[0]).includes('/api/taskforce/ui-state?key=workspace-sync'));
+            expect(uiStateCalls.length).toBeGreaterThan(0);
+        });
+        const pullCalls = fetchMock.mock.calls.filter((call) => typeof call[0] === 'string' && String(call[0]).includes('/sync/workspace/pull'));
+        expect(pullCalls.length).toBe(0);
+    });
+    it('does not repeatedly reload workspace-sync ui-state on equivalent rerenders', async () => {
+        let workspaceSyncReads = 0;
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                workspaceSyncReads += 1;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'local',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: {} }) });
+            }
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { rerender } = render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await waitFor(() => {
+            expect(workspaceSyncReads).toBeGreaterThan(0);
+        });
+        const baselineReads = workspaceSyncReads;
+        rerender(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await new Promise((resolve) => window.setTimeout(resolve, 150));
+        expect(workspaceSyncReads).toBe(baselineReads);
+    });
+    it('sync status modal displays runtime mode and sync source of truth separately', async () => {
+        const user = userEvent.setup();
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: {} }) });
+            }
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Cloud sync status:/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Cloud sync status:/i));
+        await waitFor(() => {
+            expect(screen.getByText('Runtime mode')).toBeInTheDocument();
+            expect(screen.getByText('local')).toBeInTheDocument();
+            expect(screen.getByText('Sync source of truth')).toBeInTheDocument();
+            expect(screen.getByText('cloud')).toBeInTheDocument();
+        });
+    });
+    it('uses apply-local route with workspace header when cloud pull merges into local workspace', async () => {
+        const cloudSyncApiPath = path.join(process.cwd(), 'src/sync/cloudSyncApi.ts');
+        const cloudSyncApiSource = fs.readFileSync(cloudSyncApiPath, 'utf8');
+        expect(cloudSyncApiSource).toContain("'/api/taskforce/sync/workspace/apply-local'");
+        expect(cloudSyncApiSource).toContain("'x-taskforce-workspace-id': workspaceId");
+        expect(cloudSyncApiSource).toContain("if (pathname === '/taskforce' || pathname.startsWith('/taskforce/'))");
+        expect(cloudSyncApiSource).toContain("return '/taskforce/api/taskforce/sync/workspace/apply-local';");
+    });
+    it('pulls cloud tasks into the active non-default local workspace', async () => {
+        const cloudSyncApiPath = path.join(process.cwd(), 'src/sync/cloudSyncApi.ts');
+        const cloudSyncApiSource = fs.readFileSync(cloudSyncApiPath, 'utf8');
+        const syncServicePath = path.join(process.cwd(), 'src/sync/syncService.ts');
+        const syncServiceSource = fs.readFileSync(syncServicePath, 'utf8');
+        expect(cloudSyncApiSource).toContain("new URLSearchParams({ limit: String(input.limit), workspaceId: input.workspaceId })");
+        expect(cloudSyncApiSource).toContain("resolveCloudAuthUrl('/api/taskforce/sync/workspace/pull')");
+        expect(cloudSyncApiSource).toContain("const applyPayload = JSON.stringify({ workspaceId, changes });");
+        expect(syncServiceSource).toContain('const applyResult = await applyLocalWorkspaceChanges(input.workspaceId, changes);');
+    });
+    it('does not push local changes before first cloud hydration when source is cloud', async () => {
+        const orchestratorPath = path.join(process.cwd(), 'src/hooks/useSyncOrchestrator.ts');
+        const orchestratorSource = fs.readFileSync(orchestratorPath, 'utf8');
+        expect(orchestratorSource).toContain('push_blocked_waiting_hydration_force_pull');
+        expect(orchestratorSource).toContain('onboardingCompletedRef.current');
+        expect(orchestratorSource).toContain('If a local mutation happened before initial cloud hydration finished, flush it now.');
+        expect(orchestratorSource).toContain('persistWorkspaceSyncPatch({ onboardingCompleted: true })');
+    });
+    it('keeps local workspace context authoritative over cloud auth session workspace id', async () => {
+        const useTaskforcePath = path.join(process.cwd(), 'src/hooks/useTaskforce.ts');
+        const useTaskforceSource = fs.readFileSync(useTaskforcePath, 'utf8');
+        expect(useTaskforceSource).toContain("const keepLocalWorkspaceContext = runtimeMode === 'local' || authOnlyCloudMode;");
+        expect(useTaskforceSource).toContain('Local runtime resolves workspace identity from local DB via /api/taskforce/config.');
+        expect(useTaskforceSource).toContain('Do not override it from cloud auth session payloads.');
+    });
+    it.skip('blocks local cloud-sync pull/apply when workspaceId remains default', async () => {
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'default'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'default'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        changes: [{ op: 'upsert', archived: false, task: { id: 'task-cloud-generated-id' } }],
+                        nextCursor: 'cursor-default-block',
+                        hasMore: false
+                    })
+                });
+            }
+            if (url === '/api/taskforce/sync/workspace/apply-local') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/ui-state'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Cloud sync status:/i)).toBeInTheDocument();
+        });
+        const pullCalls = fetchMock.mock.calls.filter((call) => typeof call[0] === 'string' && String(call[0]).includes('/sync/workspace/pull'));
+        expect(pullCalls.length).toBe(0);
+        const applyCalls = fetchMock.mock.calls.filter((call) => call[0] === '/api/taskforce/sync/workspace/apply-local');
+        expect(applyCalls.length).toBe(0);
+    });
+    it.skip('removes cloud-deleted tasks from UI immediately even when local refresh request fails', async () => {
+        const localTask = {
+            id: 'task-delete-immediate-1',
+            title: 'Delete me immediately',
+            description: null,
+            category: 'general',
+            type: 'feature',
+            priority: 2,
+            createdAt: new Date().toISOString(),
+            status: 'task'
+        };
+        let tasksRequestCount = 0;
+        let releasePull;
+        const pullGate = new Promise((resolve) => {
+            releasePull = resolve;
+        });
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                tasksRequestCount += 1;
+                if (tasksRequestCount === 1) {
+                    return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [localTask] }) });
+                }
+                return Promise.resolve({ ok: false, status: 500, json: () => Promise.resolve({ error: 'refresh failed' }) });
+            }
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/handshake')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+                return pullGate.then(() => Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        changes: [{ op: 'delete', taskId: 'task-delete-immediate-1' }],
+                        nextCursor: 'cursor-delete-immediate',
+                        hasMore: false
+                    })
+                }));
+            }
+            if (url === '/api/taskforce/sync/workspace/apply-local') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/ui-state'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByText('1/1')).toBeInTheDocument();
+        });
+        if (releasePull)
+            releasePull();
+        await waitFor(() => {
+            expect(screen.getByText('0/0')).toBeInTheDocument();
+        });
+    });
+    it.skip('retries pull automatically after transient cloud failure and applies changes on reconnect', async () => {
+        const cloudTask = {
+            id: 'task-retry-reconnect-1',
+            title: 'Recovered after retry',
+            description: null,
+            category: 'general',
+            type: 'feature',
+            priority: 2,
+            createdAt: new Date().toISOString(),
+            status: 'task'
+        };
+        let pullAttempt = 0;
+        let tasksFetchCount = 0;
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                tasksFetchCount += 1;
+                if (tasksFetchCount >= 2) {
+                    return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [cloudTask] }) });
+                }
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            }
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/handshake')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+                pullAttempt += 1;
+                if (pullAttempt === 1) {
+                    return Promise.resolve({ ok: false, status: 503, json: () => Promise.resolve({ error: 'unavailable' }) });
+                }
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        changes: [{ op: 'upsert', archived: false, task: cloudTask }],
+                        nextCursor: 'cursor-retry-success',
+                        hasMore: false
+                    })
+                });
+            }
+            if (url === '/api/taskforce/sync/workspace/apply-local') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/ui-state'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            const firstPull = fetchMock.mock.calls.find((call) => typeof call[0] === 'string' && String(call[0]).includes('/sync/workspace/pull'));
+            expect(firstPull).toBeTruthy();
+        });
+        await waitFor(() => {
+            const pullCalls = fetchMock.mock.calls.filter((call) => typeof call[0] === 'string' && String(call[0]).includes('/sync/workspace/pull'));
+            expect(pullCalls.length).toBeGreaterThanOrEqual(2);
+        }, { timeout: 5000 });
+        await waitFor(() => {
+            const applyCalls = fetchMock.mock.calls.filter((call) => call[0] === '/api/taskforce/sync/workspace/apply-local');
+            expect(applyCalls.length).toBeGreaterThanOrEqual(1);
+        }, { timeout: 5000 });
+    });
+    it.skip('retries pull automatically after transient apply-local failures and recovers', async () => {
+        const cloudTask = {
+            id: 'task-retry-apply-failure-1',
+            title: 'Apply retry recovered',
+            description: null,
+            category: 'general',
+            type: 'feature',
+            priority: 2,
+            createdAt: new Date().toISOString(),
+            status: 'task'
+        };
+        let applyAttempt = 0;
+        let pullAttempt = 0;
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/handshake')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+                pullAttempt += 1;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        changes: [{ op: 'upsert', archived: false, task: cloudTask }],
+                        nextCursor: `cursor-apply-retry-${pullAttempt}`,
+                        hasMore: false
+                    })
+                });
+            }
+            if (url === '/api/taskforce/sync/workspace/apply-local' || url === '/taskforce/api/taskforce/sync/workspace/apply-local') {
+                applyAttempt += 1;
+                if (applyAttempt <= 2) {
+                    return Promise.resolve({ ok: false, status: 503, json: () => Promise.resolve({ error: 'temp apply failure' }) });
+                }
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/ui-state'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            const firstPull = fetchMock.mock.calls.find((call) => typeof call[0] === 'string' && String(call[0]).includes('/sync/workspace/pull'));
+            expect(firstPull).toBeTruthy();
+        });
+        await waitFor(() => {
+            const pullCalls = fetchMock.mock.calls.filter((call) => typeof call[0] === 'string' && String(call[0]).includes('/sync/workspace/pull'));
+            expect(pullCalls.length).toBeGreaterThanOrEqual(2);
+        }, { timeout: 6000 });
+        await waitFor(() => {
+            const primaryApplyCalls = fetchMock.mock.calls.filter((call) => call[0] === '/api/taskforce/sync/workspace/apply-local');
+            expect(primaryApplyCalls.length).toBeGreaterThanOrEqual(2);
+        }, { timeout: 6000 });
+    });
+    it.skip('reset cursor + full pull triggers a new pull request without cursor param', async () => {
+        const user = userEvent.setup();
+        const pullUrls = [];
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: 'cursor-existing'
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/handshake')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+                pullUrls.push(url);
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        changes: [],
+                        nextCursor: 'cursor-next',
+                        hasMore: false
+                    })
+                });
+            }
+            if (url === '/api/taskforce/sync/workspace/apply-local') {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/ui-state')) {
+                if (init?.method === 'POST') {
+                    return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+                }
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: {} }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(pullUrls.length).toBeGreaterThan(0);
+        });
+        expect(pullUrls[0]).toContain('cursor=cursor-existing');
+        await user.click(screen.getByTitle(/Cloud sync status:/i));
+        await waitFor(() => {
+            expect(screen.getByRole('button', { name: 'Reset Cursor + Full Pull' })).toBeInTheDocument();
+        });
+        const pullCountBeforeReset = pullUrls.length;
+        await user.click(screen.getByRole('button', { name: 'Reset Cursor + Full Pull' }));
+        await waitFor(() => {
+            expect(pullUrls.length).toBeGreaterThan(pullCountBeforeReset);
+        });
+        await waitFor(() => {
+            const afterResetPullUrls = pullUrls.slice(pullCountBeforeReset);
+            expect(afterResetPullUrls.length).toBeGreaterThan(0);
+            const hasCursorlessPull = afterResetPullUrls.some((entry) => (entry.includes('workspaceId=workspace-local-active') && !entry.includes('cursor=')));
+            expect(hasCursorlessPull).toBe(true);
+        });
+    });
+    it.skip('handles pull 401 by transitioning to signed-out local auth state', async () => {
+        let authSessionCalls = 0;
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                authSessionCalls += 1;
+                if (authSessionCalls === 1) {
+                    return Promise.resolve({
+                        ok: true,
+                        json: () => Promise.resolve({
+                            authenticated: true,
+                            runtimeMode: 'local',
+                            authRequiredForApi: false
+                        })
+                    });
+                }
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: false,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/handshake')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+                return Promise.resolve({ ok: false, status: 401, json: () => Promise.resolve({ error: 'Unauthorized' }) });
+            }
+            if (url.includes('/api/taskforce/ui-state'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByPlaceholderText('Email')).toBeInTheDocument();
+        });
+    });
+    it.skip('does not downgrade workspace context when /workspaces returns default', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: true,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-cloud-active'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-cloud-active',
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            workspaceId: 'workspace-cloud-active',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false,
+                            workspace: {
+                                id: 'workspace-cloud-active',
+                                slug: 'workspace-cloud-active',
+                                name: 'Cloud Active',
+                                description: null
+                            },
+                            suggestedWorkspaceName: ''
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'cloud',
+                            supportsCloudAuth: true,
+                            supportsAdminManagedSetupOverrides: true,
+                            supportsPackageScriptSetupOverrides: false
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        currentWorkspaceId: 'default',
+                        workspaces: [
+                            { id: 'workspace-cloud-active', slug: 'workspace-cloud-active', name: 'Cloud Active', role: 'owner' }
+                        ]
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
+            if (url.includes('/api/taskforce/archive'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
+            if (url.includes('/api/taskforce/categories'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            if (url.includes('/api/taskforce/types'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
+            if (url.includes('/api/taskforce/priorities'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ priorities: [] }) });
+            if (url.includes('/api/taskforce/approaches'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ approaches: [] }) });
+            if (url.includes('/api/taskforce/specialists'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ specialists: [] }) });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('/api/taskforce/ui-state'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.some((call) => typeof call[0] === 'string' && String(call[0]).includes('/api/taskforce/workspaces'))).toBe(true);
+        });
+        await waitFor(() => {
+            expect(screen.getByTitle('Workspace ID: workspace-cloud-active')).toBeInTheDocument();
+        });
+    });
+});