@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/TaskforceCore.test.js

@@ -1,11 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { render, screen, waitFor } from '@testing-library/react';
+import { act, render, screen, waitFor, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { MemoryRouter } from 'react-router-dom';
 import { TaskforceCore } from './TaskforceCore';
 import fs from 'fs';
 import path from 'path';
+import modalStyles from './components/ui/Modal.module.css';
 const mockTasks = [
     {
         id: 'task-20260130-abc123',
@@ -32,19 +33,63 @@ const mockConfig = {
 const mockCategories = {
     categories: [{ value: 'general', label: 'General' }]
 };
+function jsonResponse(body, status = 200) {
+    return Promise.resolve({
+        ok: status >= 200 && status < 300,
+        status,
+        statusText: '',
+        headers: {
+            get: () => null
+        },
+        text: () => Promise.resolve(JSON.stringify(body)),
+        json: () => Promise.resolve(body)
+    });
+}
 describe('TaskforceCore Integration', () => {
     beforeEach(() => {
         localStorage.clear();
         vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } }) });
+            }
+            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/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            version: 2,
+                            enabled: false,
+                            phase: 'idle',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
+                        }
+                    })
+                });
+            }
             if (url.includes('/api/taskforce/config')) {
                 return Promise.resolve({ ok: true, json: () => Promise.resolve(mockConfig) });
             }
+            if (url.includes('/api/taskforce/global-settings')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+            }
             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/data-version')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ dataVersion: 1 }) });
+            }
             if (url.includes('/api/taskforce/types')) {
                 return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
             }
@@ -60,6 +105,55 @@ describe('TaskforceCore Integration', () => {
             return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
         }));
     });
+    afterEach(() => {
+        delete globalThis.__DEBUG_MODE__;
+    });
+    it('keeps board content fully visible when zen mode is enabled', async () => {
+        const user = userEvent.setup();
+        let fullscreenElement = null;
+        const requestFullscreen = vi.fn(async function () {
+            fullscreenElement = this;
+            Object.defineProperty(document, 'fullscreenElement', {
+                configurable: true,
+                get: () => fullscreenElement
+            });
+            document.dispatchEvent(new Event('fullscreenchange'));
+        });
+        const exitFullscreen = vi.fn(async () => {
+            fullscreenElement = null;
+            Object.defineProperty(document, 'fullscreenElement', {
+                configurable: true,
+                get: () => fullscreenElement
+            });
+            document.dispatchEvent(new Event('fullscreenchange'));
+        });
+        Object.defineProperty(document, 'fullscreenElement', {
+            configurable: true,
+            get: () => fullscreenElement
+        });
+        Object.defineProperty(document.documentElement, 'requestFullscreen', {
+            configurable: true,
+            value: requestFullscreen
+        });
+        Object.defineProperty(document, 'exitFullscreen', {
+            configurable: true,
+            value: exitFullscreen
+        });
+        const { container } = render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle('Visible active tasks / total active tasks')).toHaveTextContent('1/1');
+        });
+        const boardContent = container.querySelector('[class*="standaloneContent"]');
+        expect(boardContent).not.toBeNull();
+        expect(boardContent).not.toHaveStyle({ opacity: '0.1' });
+        await user.click(screen.getByTitle(/enter zen mode/i));
+        await waitFor(() => {
+            expect(requestFullscreen).toHaveBeenCalledTimes(1);
+        });
+        expect(screen.getByTitle(/exit zen mode/i)).toBeInTheDocument();
+        expect(boardContent).not.toHaveStyle({ opacity: '0.1' });
+        expect(screen.getByTitle('Visible active tasks / total active tasks')).toHaveTextContent('1/1');
+    });
     it('5.1 & 5.3 Renders main header and task list', async () => {
         render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
         // Header check
@@ -71,6 +165,68 @@ describe('TaskforceCore Integration', () => {
             expect(screen.getByText('1/1')).toBeInTheDocument();
         });
     });
+    it('shows the header sync badge as off when local runtime is signed out', async () => {
+        vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } }) });
+            }
+            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/ui-state?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: {
+                            version: 2,
+                            enabled: true,
+                            phase: 'active',
+                            pullCursor: null,
+                            lastPullAt: '2026-03-15T19:30:00.000Z',
+                            lastPushAt: '2026-03-15T19:31:00.000Z',
+                            lastSyncedAt: '2026-03-15T19:31:00.000Z'
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockConfig) });
+            }
+            if (url.includes('/api/taskforce/global-settings')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+            }
+            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/data-version')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ dataVersion: 1 }) });
+            }
+            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({}) });
+        }));
+        render(_jsx(TaskforceCore, {}));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Sync manager: Off/)).toBeInTheDocument();
+        });
+    });
     it('5.2 Does not render the widget floating button', async () => {
         const { container } = render(_jsx(TaskforceCore, {}));
         expect(screen.queryByTitle('Open Taskforce')).not.toBeInTheDocument();
@@ -87,6 +243,267 @@ describe('TaskforceCore Integration', () => {
             expect(onCountChange).toHaveBeenCalledWith(1);
         });
     });
+    it('unblocks cloud loading before slow reference data finishes', async () => {
+        let resolveCategories = () => { };
+        const categoriesGate = new Promise((resolve) => {
+            resolveCategories = resolve;
+        });
+        vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        baseUrl: 'https://app.taskforce.example',
+                        apiBaseUrl: 'https://app.taskforce.example/api',
+                        workspaceMode: 'multi-cloud',
+                        workspaceSwitchingEnabled: true,
+                        authSource: 'cloud'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    email: 'member@example.com',
+                    userId: 'user-1',
+                    workspaceId: 'workspace-1',
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    workspaces: [{
+                            id: 'workspace-1',
+                            slug: 'workspace-1',
+                            name: 'Fast Workspace',
+                            description: null,
+                            role: 'owner',
+                            status: 'active',
+                            betaAccess: true
+                        }],
+                    currentWorkspaceId: 'workspace-1'
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return jsonResponse({
+                    gate: 'ok',
+                    canAccessApp: true,
+                    canAccessPlans: true
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: {
+                        version: 2,
+                        enabled: false,
+                        phase: 'idle',
+                        pullCursor: null,
+                        lastPullAt: null,
+                        lastPushAt: null,
+                        lastSyncedAt: null
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    runtimeMode: 'cloud',
+                    storagePath: '',
+                    shortcut: 'Alt+T',
+                    projectName: 'Fast Workspace',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: mockTasks });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/version')) {
+                return jsonResponse({ ok: true, build: { version: '1.0.0' } });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return categoriesGate.then(() => jsonResponse(mockCategories));
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return jsonResponse({ types: [] });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return jsonResponse({ priorities: [] });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return jsonResponse({ templates: [] });
+            }
+            if (url.includes('/api/taskforce/initiative-templates')) {
+                return jsonResponse({ templates: [] });
+            }
+            if (url.includes('/api/taskforce/environments')) {
+                return jsonResponse({ environments: [] });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return jsonResponse({ approaches: [] });
+            }
+            if (url.includes('/api/taskforce/taxonomies')) {
+                return jsonResponse({ taxonomies: [] });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return jsonResponse({ specialists: [] });
+            }
+            if (url.includes('/api/taskforce/data-version')) {
+                return jsonResponse({ dataVersion: 1 });
+            }
+            return jsonResponse({});
+        }));
+        render(_jsx(TaskforceCore, { config: {} }));
+        await waitFor(() => {
+            expect(screen.queryByText('Loading Taskforce')).not.toBeInTheDocument();
+            expect(screen.getByText('Fast Workspace')).toBeInTheDocument();
+            expect(screen.getByText('1/1')).toBeInTheDocument();
+        });
+        resolveCategories();
+        await waitFor(() => {
+            expect(screen.getByText('1/1')).toBeInTheDocument();
+        });
+    });
+    it('deduplicates cloud bootstrap workspace, task, and workflow fetches', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        baseUrl: 'https://app.taskforce.example',
+                        apiBaseUrl: 'https://app.taskforce.example/api',
+                        workspaceMode: 'multi-cloud',
+                        workspaceSwitchingEnabled: true,
+                        authSource: 'cloud'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    email: 'member@example.com',
+                    userId: 'user-1',
+                    workspaceId: 'workspace-1',
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    workspaces: [{
+                            id: 'workspace-1',
+                            slug: 'workspace-1',
+                            name: 'Fast Workspace',
+                            description: null,
+                            role: 'owner',
+                            status: 'active',
+                            betaAccess: true
+                        }],
+                    currentWorkspaceId: 'workspace-1'
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return jsonResponse({
+                    gate: 'ok',
+                    canAccessApp: true,
+                    canAccessPlans: true
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: {
+                        version: 2,
+                        enabled: false,
+                        phase: 'idle',
+                        pullCursor: null,
+                        lastPullAt: null,
+                        lastPushAt: null,
+                        lastSyncedAt: null
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    runtimeMode: 'cloud',
+                    storagePath: '',
+                    shortcut: 'Alt+T',
+                    projectName: 'Fast Workspace',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: mockTasks });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/version')) {
+                return jsonResponse({ ok: true, build: { version: '1.0.0' } });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return jsonResponse(mockCategories);
+            }
+            if (url.includes('/api/taskforce/types')) {
+                return jsonResponse({ types: [] });
+            }
+            if (url.includes('/api/taskforce/priorities')) {
+                return jsonResponse({ priorities: [] });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return jsonResponse({ templates: [] });
+            }
+            if (url.includes('/api/taskforce/initiative-templates')) {
+                return jsonResponse({ templates: [] });
+            }
+            if (url.includes('/api/taskforce/environments')) {
+                return jsonResponse({ environments: [] });
+            }
+            if (url.includes('/api/taskforce/approaches')) {
+                return jsonResponse({ approaches: [] });
+            }
+            if (url.includes('/api/taskforce/taxonomies')) {
+                return jsonResponse({ taxonomies: [] });
+            }
+            if (url.includes('/api/taskforce/specialists')) {
+                return jsonResponse({ specialists: [] });
+            }
+            if (url.includes('/api/taskforce/data-version')) {
+                return jsonResponse({ dataVersion: 1 });
+            }
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: {} }));
+        await waitFor(() => {
+            expect(screen.getByText('Fast Workspace')).toBeInTheDocument();
+            expect(screen.getByText('1/1')).toBeInTheDocument();
+        });
+        const requestedUrls = fetchMock.mock.calls.map(([url]) => String(url));
+        expect(requestedUrls.filter((url) => url.includes('/api/taskforce/workspaces'))).toHaveLength(1);
+        expect(requestedUrls.filter((url) => url.includes('/api/taskforce/workflow-templates'))).toHaveLength(1);
+    });
     it('5.7 Deep Link: Opens specific task when short ID is provided', async () => {
         render(_jsx(TaskforceCore, { initialTaskId: "abc123" }));
         await waitFor(() => {
@@ -96,6 +513,73 @@ describe('TaskforceCore Integration', () => {
             expect(screen.getByDisplayValue('Integration Task 1')).toBeInTheDocument();
         });
     });
+    it('does not prompt for unsaved changes when closing an untouched task with defaulted approach', async () => {
+        const user = userEvent.setup();
+        render(_jsx(TaskforceCore, { initialTaskId: "abc123" }));
+        await waitFor(() => {
+            expect(screen.getByText('Update')).toBeInTheDocument();
+            expect(screen.getByDisplayValue('Integration Task 1')).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle('Close'));
+        await waitFor(() => {
+            expect(screen.queryByText('You have unsaved changes. Would you like to save them?')).not.toBeInTheDocument();
+            expect(screen.queryByDisplayValue('Integration Task 1')).not.toBeInTheDocument();
+        });
+    });
+    it('does not send createdAt or createdBy when updating an existing task', async () => {
+        const user = userEvent.setup();
+        const fetchMock = vi.fn((url, init) => {
+            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: [] }) });
+            }
+            if (url.includes(`/api/taskforce/task/${mockTasks[0].id}`) && init?.method === 'PATCH') {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockTasks[0],
+                        title: 'Integration Task 1 Updated',
+                        updatedAt: new Date().toISOString()
+                    })
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { initialTaskId: "abc123" }));
+        await waitFor(() => {
+            expect(screen.getByDisplayValue('Integration Task 1')).toBeInTheDocument();
+        });
+        const titleInput = screen.getByDisplayValue('Integration Task 1');
+        await user.clear(titleInput);
+        await user.type(titleInput, 'Integration Task 1 Updated');
+        await user.click(screen.getByText('Update'));
+        await waitFor(() => {
+            const patchCall = fetchMock.mock.calls.find((call) => String(call[0]).includes(`/api/taskforce/task/${mockTasks[0].id}`)
+                && call[1]?.method === 'PATCH');
+            expect(patchCall).toBeTruthy();
+            const body = JSON.parse(String(patchCall?.[1]?.body || '{}'));
+            expect(body.createdAt).toBeUndefined();
+            expect(body.createdBy).toBeUndefined();
+        });
+    });
     it('Navigation: Can switch to Settings', async () => {
         render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
         await waitFor(() => {
@@ -220,134 +704,112 @@ describe('TaskforceCore Integration', () => {
         });
         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 () => {
+    it('prefers server app ui-state over stale local storage for groupBy on bootstrap', async () => {
+        localStorage.setItem('taskforce.uiState.app.v1.bootstrap', JSON.stringify({ groupBy: 'category' }));
         const fetchMock = vi.fn((url) => {
-            if (url.includes('/api/taskforce/auth/session')) {
+            if (url.includes('/api/taskforce/config')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        authenticated: false,
+                        ...mockConfig,
                         runtimeMode: 'cloud',
-                        authRequiredForApi: true
+                        authRequiredForApi: false,
+                        userId: 'user-1',
+                        workspaceId: 'default'
                     })
                 });
             }
-            if (url.includes('/api/taskforce/config')) {
+            if (url.includes('/api/taskforce/categories')) {
                 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
-                        }
+                        categories: [{ value: 'general', label: 'General' }]
                     })
                 });
             }
             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({
+                        tasks: [
+                            {
+                                id: 'task-pri-1',
+                                title: 'Priority One Active',
+                                description: null,
+                                category: 'general',
+                                type: 'feature',
+                                priority: 1,
+                                createdAt: new Date().toISOString(),
+                                completed: false,
+                                status: 'task'
+                            },
+                            {
+                                id: 'task-pri-2',
+                                title: 'Priority Two Active',
+                                description: null,
+                                category: 'general',
+                                type: 'feature',
+                                priority: 2,
+                                createdAt: new Date().toISOString(),
+                                completed: false,
+                                status: 'task'
+                            }
+                        ]
+                    })
+                });
             }
-            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;
+            if (url.includes('/api/taskforce/archive')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
             }
-            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('/api/taskforce/priorities')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        priorities: [
+                            { value: 1, label: 'P1' },
+                            { value: 2, label: 'P2' }
+                        ]
+                    })
                 });
             }
-            if (url.includes('https://cloud.example.com/api/taskforce/auth/session')) {
+            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({
-                        authenticated: true,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false,
-                        email: 'member@example.com',
-                        userId: 'user-member',
-                        workspaceId: 'workspace-local-active',
-                        betaAccess: true
+                        success: true,
+                        state: {
+                            groupBy: 'priority',
+                            hasInitedFilters: true,
+                            filterPriorities: [1, 2],
+                            filterCategories: ['general'],
+                            filterTypes: ['feature'],
+                            filterStatus: ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']
+                        }
                     })
                 });
             }
-            if (url.includes('/api/taskforce/config')) {
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
                 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
+                        success: true,
+                        state: {
+                            version: 2,
+                            enabled: false,
+                            phase: 'idle',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
                         }
                     })
                 });
             }
-            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/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: [] }) });
@@ -355,50 +817,25 @@ describe('TaskforceCore Integration', () => {
             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'
-                    }
-                })
-            });
-        }
+        render(_jsx(TaskforceCore, { mode: "standalone" }));
         await waitFor(() => {
-            expect(screen.getByText(/Signed in as/i)).toBeInTheDocument();
-            expect(screen.getByText('member@example.com')).toBeInTheDocument();
+            expect(screen.getByTitle('Add task to P1')).toBeInTheDocument();
+            expect(screen.getByTitle('Add task to P2')).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);
+        expect(screen.queryByTitle('Add task to General')).not.toBeInTheDocument();
     });
-    it('allows local runtime to open shared /login and register flow', async () => {
+    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: 'local',
-                        authRequiredForApi: false
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
                     })
                 });
             }
@@ -407,48 +844,55 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         ...mockConfig,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
                         setupState: {
                             globalSetupState: 'present',
                             workspaceSetupState: 'present',
-                            runtimeMode: 'local',
-                            workspaceId: 'workspace-local-active',
+                            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: ['/login?mode=register&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        const { container } = render(_jsx(MemoryRouter, { initialEntries: ['/'], 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(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('allows returning to sign-in/register from forgot mode', async () => {
-        const user = userEvent.setup();
+    it('allows public access to /pricing in cloud mode without login redirect', 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
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
                     })
                 });
             }
@@ -457,237 +901,277 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         ...mockConfig,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
                         setupState: {
                             globalSetupState: 'present',
                             workspaceSetupState: 'present',
-                            runtimeMode: 'local',
-                            workspaceId: 'workspace-local-active',
+                            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/workflow-templates')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        plans: [
+                            {
+                                planId: 'pro',
+                                displayName: 'Pro Plan test mode',
+                                status: 'active',
+                                features: [],
+                                pricing: { month: null, year: null },
+                                defaultVersion: null
+                            }
+                        ]
+                    })
+                });
             }
             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' }));
+        render(_jsx(MemoryRouter, { initialEntries: ['/pricing'], children: _jsx(TaskforceCore, {}) }));
         await waitFor(() => {
-            expect(screen.getByText('Sign in with your account credentials.')).toBeInTheDocument();
-            expect(screen.getByRole('button', { name: 'Register' })).toBeInTheDocument();
+            expect(screen.queryByPlaceholderText('Email')).not.toBeInTheDocument();
+            expect(screen.getByText('Pro Plan test mode')).toBeInTheDocument();
+            expect(screen.getByRole('heading', { name: 'Subscription Plans' })).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) => {
+    it('redirects authenticated users with pending plan selection to the plans page', 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
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
                     })
                 });
             }
             if (url.includes('/api/taskforce/config')) {
-                const mode = selectedMode;
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
                         ...mockConfig,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        workspaceSwitchingEnabled: true,
                         setupState: {
-                            globalSetupState: mode ? 'present' : 'missing',
+                            globalSetupState: 'present',
                             workspaceSetupState: 'present',
-                            runtimeMode: 'local',
-                            workspaceId: 'default',
-                            mode: mode || 'core',
+                            runtimeMode: 'cloud',
+                            workspaceId: 'workspace-1',
+                            mode: 'core',
                             forceSetup: false,
-                            forceGlobalSetup: true,
+                            forceGlobalSetup: false,
                             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/workspaces')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        workspaces: [
+                            {
+                                id: 'workspace-1',
+                                slug: 'workspace-1',
+                                name: 'Workspace 1',
+                                description: null,
+                                role: 'owner',
+                                status: 'active',
+                                betaAccess: true
+                            }
+                        ]
+                    })
+                });
             }
-            if (url.includes('/api/taskforce/tasks')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        gate: 'plan_selection_required',
+                        hasEntitlement: false,
+                        canAccessApp: false,
+                        canAccessPlans: true,
+                        message: 'Choose a plan to continue.'
+                    })
+                });
             }
-            if (url.includes('/api/taskforce/workflow-templates')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        plans: [
+                            {
+                                planId: 'starter',
+                                displayName: 'Starter',
+                                status: 'active',
+                                features: [],
+                                pricing: {
+                                    month: { pricingType: 'free', stripePriceId: null, unitAmount: 0, currency: null, interval: 'month' },
+                                    year: null
+                                },
+                                defaultVersion: {
+                                    planVersionId: 'starter-v1',
+                                    versionNumber: 1,
+                                    seatLimit: null,
+                                    metadata: {}
+                                }
+                            }
+                        ]
+                    })
+                });
             }
-            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')) {
+            if (url.includes('/api/taskforce/billing/status')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        authenticated: true,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false
+                        planId: 'starter',
+                        planName: 'Starter',
+                        entitlementState: 'active'
                     })
                 });
             }
-            if (url.includes('/api/taskforce/config')) {
+            if (url.includes('/api/taskforce/billing/status')) {
                 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
-                        }
+                        planId: 'starter',
+                        planName: 'Starter',
+                        entitlementState: 'active'
                     })
                 });
             }
-            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/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/workflow-templates')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            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({}) });
         });
         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';
+            expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+            expect(screen.getByText('Choose a plan to continue.')).toBeInTheDocument();
         });
-        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;
+    it('redirects authenticated users with a blocking account access gate to the plans page', 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
+                        authenticated: true,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
                     })
                 });
             }
             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',
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        workspaceSwitchingEnabled: true,
                         setupState: {
                             globalSetupState: 'present',
-                            workspaceSetupState: firstPass ? 'missing' : 'present',
-                            runtimeMode: 'local',
-                            workspaceId: 'workspace-local-refresh',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            workspaceId: 'workspace-1',
                             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
+                            forceWorkspaceSetup: false
                         }
                     })
                 });
             }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        workspaces: [
+                            {
+                                id: 'workspace-1',
+                                slug: 'workspace-1',
+                                name: 'Workspace 1',
+                                description: null,
+                                role: 'owner',
+                                status: 'active',
+                                betaAccess: true
+                            }
+                        ]
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        gate: 'misconfigured',
+                        hasEntitlement: false,
+                        canAccessApp: false,
+                        canAccessPlans: true,
+                        message: 'Signup monetization is misconfigured.'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        plans: [
+                            {
+                                planId: 'starter',
+                                displayName: 'Starter',
+                                status: 'active',
+                                features: [],
+                                pricing: {
+                                    month: { pricingType: 'free', stripePriceId: null, unitAmount: 0, currency: null, interval: 'month' },
+                                    year: null
+                                },
+                                defaultVersion: {
+                                    planVersionId: 'starter-v1',
+                                    versionNumber: 1,
+                                    seatLimit: null,
+                                    metadata: {}
+                                }
+                            }
+                        ]
+                    })
+                });
+            }
             if (url.includes('/api/taskforce/categories')) {
                 return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
             }
@@ -706,30 +1190,24 @@ describe('TaskforceCore Integration', () => {
             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('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+            expect(screen.getByText('Signup monetization is misconfigured. Contact support or a system administrator.')).toBeInTheDocument();
         });
-        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) => {
+    it('suppresses stale missing-entitlement gate messaging when billing status is already active', 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
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
                     })
                 });
             }
@@ -738,116 +1216,154 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         ...mockConfig,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        workspaceSwitchingEnabled: true,
                         setupState: {
                             globalSetupState: 'present',
-                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
-                            runtimeMode: 'local',
-                            workspaceId: workspaceSaved ? 'workspace-cloud-123' : 'default',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            workspaceId: 'workspace-1',
                             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
+                            forceWorkspaceSetup: false
                         }
                     })
                 });
             }
-            if (url.includes('https://cloud.example.com/api/taskforce/workspaces')) {
+            if (url.includes('/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'
+                                id: 'workspace-1',
+                                slug: 'workspace-1',
+                                name: 'Workspace 1',
+                                description: null,
+                                role: 'owner',
+                                status: 'active',
+                                betaAccess: true
                             }
                         ]
                     })
                 });
             }
-            if (url.includes('/api/taskforce/workspace-profile')) {
-                const body = JSON.parse(String(init?.body || '{}'));
-                if (body?.workspaceId === 'workspace-cloud-123')
-                    workspaceSaved = true;
+            if (url.includes('/api/taskforce/account/access-status')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        success: true,
-                        workspace: {
-                            id: 'workspace-cloud-123'
-                        }
+                        gate: 'missing_entitlement',
+                        hasEntitlement: false,
+                        canAccessApp: false,
+                        canAccessPlans: true,
+                        message: 'No entitlement is linked to this account.'
                     })
                 });
             }
-            if (url.includes('/api/taskforce/session/workspace')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        plans: [
+                            {
+                                planId: 'starter',
+                                displayName: 'Starter',
+                                status: 'active',
+                                features: [],
+                                pricing: {
+                                    month: { pricingType: 'free', stripePriceId: null, unitAmount: 0, currency: null, interval: 'month' },
+                                    year: null
+                                },
+                                defaultVersion: {
+                                    planVersionId: 'starter-v1',
+                                    versionNumber: 1,
+                                    seatLimit: null,
+                                    metadata: {}
+                                }
+                            }
+                        ]
+                    })
+                });
             }
-            if (url.includes('/api/taskforce/ui-state')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            if (url.includes('/api/taskforce/billing/status')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        planId: 'starter',
+                        planName: 'Starter',
+                        planVersionId: 'starter-v1',
+                        entitlementState: 'active'
+                    })
+                });
+            }
+            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/workflow-templates')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('/api/taskforce/types')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ types: [] }) });
             }
-            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 }));
+            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({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&gate=missing_entitlement'], children: _jsx(TaskforceCore, {}) }));
         await waitFor(() => {
-            expect(screen.getByRole('option', { name: /Cloud Project 123/ })).toBeInTheDocument();
+            expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+            expect(screen.getByText('Starter')).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();
+            expect(screen.queryByText('No entitlement is linked to this account.')).not.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';
+    });
+    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({}) });
         });
-        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);
+        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('enables workspace cloud sync from local setup when signed in and checkbox is selected', async () => {
+    it('keeps account menu in bootstrap-pending state until runtime config resolves, then shows signed-in identity immediately', async () => {
         const user = userEvent.setup();
-        let workspaceSaved = false;
-        const fetchMock = vi.fn((url, init) => {
-            if (url.includes('/api/taskforce/auth/session')) {
+        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
+                        authRequiredForApi: false,
+                        email: 'member@example.com',
+                        userId: 'user-member',
+                        workspaceId: 'workspace-local-active',
+                        betaAccess: true
                     })
                 });
             }
@@ -858,101 +1374,115 @@ describe('TaskforceCore Integration', () => {
                         ...mockConfig,
                         runtimeMode: 'local',
                         authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active',
                         setupState: {
                             globalSetupState: 'present',
-                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
+                            workspaceSetupState: 'present',
                             runtimeMode: 'local',
-                            workspaceId: workspaceSaved ? 'workspace-local-setup-1' : 'default',
+                            workspaceId: 'workspace-local-active',
                             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
+                            forceWorkspaceSetup: false
                         }
                     })
                 });
             }
-            if (url.includes('/api/taskforce/workspace-profile')) {
-                workspaceSaved = true;
+            if (url.includes('/api/taskforce/billing/status')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        success: true,
-                        workspace: {
-                            id: 'workspace-local-setup-1'
-                        }
+                        planId: 'starter',
+                        planName: 'Starter',
+                        entitlementState: 'active'
                     })
                 });
             }
-            if (url.includes('/api/taskforce/ui-state')) {
-                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/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: ['/setup?step=workspace'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        const accountButton = await screen.findByTitle(/Account/i);
+        await user.click(accountButton);
+        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('Workspace Setup Required')).toBeInTheDocument();
+            expect(screen.queryByText(/Signed in as/i)).not.toBeInTheDocument();
+            expect(screen.getByText('member@example.com')).toBeInTheDocument();
+            expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/billing/status'))).toBe(true);
         });
         await waitFor(() => {
-            expect(screen.getByRole('checkbox', { name: /sync to cloud after setup/i })).toBeInTheDocument();
+            expect(screen.getByText('Subscription')).toBeInTheDocument();
+            expect(screen.getByText('Starter')).toBeInTheDocument();
+            expect(screen.getByText('Runtime')).toBeInTheDocument();
+            expect(screen.getByText('LOCAL')).toBeInTheDocument();
+            expect(screen.getByText('Environment')).toBeInTheDocument();
+            expect(screen.getByText('CLOUD.EXAMPLE.COM')).toBeInTheDocument();
+            expect(screen.queryByText(/Current Plan:/i)).not.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 user.click(screen.getByRole('button', { name: /Subscription Starter/i }));
         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';
+            expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
         });
-        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 () => {
+        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);
+    }, 10000);
+    it('shows connected environment in the account menu', 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')) {
+        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,
-                        workspaceId: workspaceSaved ? 'workspace-local-flow-1' : 'default'
+                        email: 'member@example.com',
+                        userId: 'user-member',
+                        workspaceId: 'workspace-local-active',
+                        betaAccess: true
                     })
                 });
             }
@@ -963,115 +1493,2140 @@ describe('TaskforceCore Integration', () => {
                         ...mockConfig,
                         runtimeMode: 'local',
                         authRequiredForApi: false,
-                        workspaceId: workspaceSaved ? 'workspace-local-flow-1' : 'default',
+                        workspaceId: 'workspace-local-active',
                         setupState: {
                             globalSetupState: 'present',
-                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
+                            workspaceSetupState: 'present',
                             runtimeMode: 'local',
-                            workspaceId: workspaceSaved ? 'workspace-local-flow-1' : 'default',
+                            workspaceId: 'workspace-local-active',
                             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
+                            forceWorkspaceSetup: false
                         }
                     })
                 });
             }
-            if (url.includes('/api/taskforce/workspace-profile')) {
-                workspaceSaved = true;
+            if (url.includes('/api/taskforce/billing/status')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        success: true,
-                        workspace: { id: 'workspace-local-flow-1' }
+                        planId: 'starter',
+                        planName: 'Starter',
+                        entitlementState: 'active'
                     })
                 });
             }
-            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+            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' } }));
+        const accountButton = await screen.findByTitle(/Account/i);
+        await user.click(accountButton);
+        expect(screen.getByText('Checking sign-in status...')).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('Subscription')).toBeInTheDocument();
+            expect(screen.getByText('Starter')).toBeInTheDocument();
+            expect(screen.getByText('Runtime')).toBeInTheDocument();
+            expect(screen.getByText('LOCAL')).toBeInTheDocument();
+            expect(screen.getByText('Environment')).toBeInTheDocument();
+            expect(screen.getByText('CLOUD.EXAMPLE.COM')).toBeInTheDocument();
+        });
+    }, 10000);
+    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({
-                        success: true,
-                        state: workspaceSyncState
+                        authenticated: false,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
                     })
                 });
             }
-            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 (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.getByPlaceholderText('Display name')).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('shows debug registration autofill only when debug mode is enabled', 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 firstRender = render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Create your Taskforce account.')).toBeInTheDocument();
+        });
+        expect(screen.queryByRole('button', { name: 'Fill Form' })).not.toBeInTheDocument();
+        firstRender.unmount();
+        globalThis.__DEBUG_MODE__ = true;
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        expect(await screen.findByRole('button', { name: 'Fill Form' })).toBeInTheDocument();
+    });
+    it('fills and submits generated debug registration credentials through the normal register flow', async () => {
+        globalThis.__DEBUG_MODE__ = true;
+        const user = userEvent.setup();
+        const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(1735689600000);
+        const fetchMock = vi.fn((input, init) => {
+            const url = String(input);
+            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: [] }) });
+            }
+            if (url.includes('/api/taskforce/auth/register')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspaceSetupRequired: false,
+                        verificationRequired: true,
+                        emailSent: true
+                    })
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        const emailInput = await screen.findByPlaceholderText('Email');
+        const displayNameInput = screen.getByPlaceholderText('Display name');
+        const passwordInput = screen.getByPlaceholderText('Password');
+        await user.click(screen.getByRole('button', { name: 'Fill Form' }));
+        expect(String(emailInput.value)).toMatch(/^debug\+[a-z0-9]+@example\.com$/);
+        expect(String(displayNameInput.value)).toMatch(/^Debug [A-Z0-9]{4}$/);
+        expect(passwordInput).toHaveValue('DebugPass123!');
+        await user.click(screen.getByRole('button', { name: 'Create Account' }));
+        await waitFor(() => {
+            const registerCall = fetchMock.mock.calls.find((call) => String(call[0]).includes('/api/taskforce/auth/register'));
+            expect(registerCall).toBeTruthy();
+            const payload = JSON.parse(String(registerCall?.[1]?.body || '{}'));
+            expect(String(registerCall?.[0] || '')).toContain('/api/taskforce/auth/register');
+            const init = registerCall?.[1];
+            expect(String(init?.method || '')).toBe('POST');
+            expect(String(init?.credentials || '')).toBe('include');
+            expect(payload.email).toBe(String(emailInput.value));
+            expect(payload.displayName).toBe(String(displayNameInput.value));
+            expect(payload.password).toBe('DebugPass123!');
+        });
+        nowSpy.mockRestore();
+    });
+    it('does not switch to verify mode after registration when verification is not required', async () => {
+        const user = userEvent.setup();
+        const fetchMock = vi.fn((input) => {
+            const url = String(input);
+            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/public/pricing')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        plans: []
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/register')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspaceSetupRequired: false,
+                        verificationRequired: false
+                    })
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&next=%2Fplans'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'local@example.com');
+        await user.type(screen.getByPlaceholderText('Display name'), 'Local User');
+        await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
+        await user.click(screen.getByRole('button', { name: 'Create Account' }));
+        await waitFor(() => {
+            expect(screen.getByPlaceholderText('Search tasks...')).toBeInTheDocument();
+        });
+        expect(screen.queryByPlaceholderText('Verification token')).not.toBeInTheDocument();
+        expect(screen.queryByRole('button', { name: 'Create Account' })).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('redirects register users to plans when signup plan configuration blocks account creation', async () => {
+        const user = userEvent.setup();
+        const fetchMock = vi.fn((input) => {
+            const url = String(input);
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        config: {
+                            baseUrl: 'http://localhost:5174',
+                            apiBaseUrl: 'http://localhost:5174',
+                            cloudAuthBaseUrl: 'http://localhost:5174',
+                            runtimeMode: 'local',
+                            authSource: 'cloud',
+                            workspaceMode: 'single-local',
+                            workspaceSwitchingEnabled: false,
+                            cloudAuthViaLocalProxy: true
+                        }
+                    })
+                });
+            }
+            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: [] }) });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        asOf: '2026-03-16T00:00:00.000Z',
+                        plans: [
+                            {
+                                planId: 'free',
+                                displayName: 'Free',
+                                status: 'active',
+                                defaultVersion: { planVersionId: 'free-v1', versionNumber: 1, seatLimit: 1, metadata: {} },
+                                features: [],
+                                pricing: {
+                                    month: { planVersionId: 'free-v1', interval: 'month', pricingType: 'free', stripePriceId: 'free:free-v1:month', displayAmount: '$0.00', unitAmount: 0, currency: 'usd' },
+                                    year: { planVersionId: 'free-v1', interval: 'year', pricingType: 'free', stripePriceId: 'free:free-v1:year', displayAmount: '$0.00', unitAmount: 0, currency: 'usd' }
+                                }
+                            }
+                        ]
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/register')) {
+                return Promise.resolve({
+                    ok: false,
+                    json: () => Promise.resolve({
+                        success: false,
+                        code: 'SIGNUP_PLAN_NOT_ENABLED',
+                        error: 'Configured default signup plan version \"team-10-v1\" belongs to a disabled plan.'
+                    })
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'local@example.com');
+        await user.type(screen.getByPlaceholderText('Display name'), 'Local User');
+        await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
+        await user.click(screen.getByRole('button', { name: 'Create Account' }));
+        await waitFor(() => {
+            expect(screen.getByText('Choose a plan to continue.')).toBeInTheDocument();
+            expect(screen.getByText('Subscription Plans')).toBeInTheDocument();
+        });
+    });
+    it('shows sign-in continuation for existing-user invites', 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: 'workspace-1',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/invite/inspect')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: 'valid',
+                        email: 'existing@example.com',
+                        workspaceId: 'workspace-1',
+                        inviteeKind: 'existing_user',
+                        passwordRequired: 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=invite&token=invite-token&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Sign in to join this workspace.')).toBeInTheDocument();
+            expect(screen.getByDisplayValue('existing@example.com')).toBeInTheDocument();
+            expect(screen.getByPlaceholderText('Password')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Sign In to Continue' })).toBeInTheDocument();
+        });
+    });
+    it('shows password creation for new-user invites', 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: 'workspace-1',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/invite/inspect')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: 'valid',
+                        email: 'new@example.com',
+                        workspaceId: 'workspace-1',
+                        inviteeKind: 'new_user',
+                        passwordRequired: true
+                    })
+                });
+            }
+            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=invite&token=invite-token&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Create your account to join this workspace.')).toBeInTheDocument();
+            expect(screen.getByPlaceholderText('Create password')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Create Account and Join' })).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?.enabled).toBe(false);
+    });
+    it('applies the selected starter taxonomy pack during workspace setup', async () => {
+        const user = userEvent.setup();
+        let workspaceSaved = false;
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    runtimeMode: 'local',
+                    authRequiredForApi: false
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'local',
+                    authRequiredForApi: false,
+                    setupState: {
+                        globalSetupState: 'present',
+                        workspaceSetupState: workspaceSaved ? 'present' : 'missing',
+                        runtimeMode: 'local',
+                        workspaceId: workspaceSaved ? 'workspace-starter-1' : 'default',
+                        mode: 'core',
+                        forceSetup: false,
+                        forceGlobalSetup: false,
+                        forceWorkspaceSetup: true,
+                        workspace: workspaceSaved
+                            ? { id: 'workspace-starter-1', slug: 'workspace-starter-1', name: 'Starter Workspace', description: 'Starter desc' }
+                            : null,
+                        suggestedWorkspaceName: 'Starter Workspace'
+                    },
+                    runtimeCapabilities: {
+                        runtimeMode: 'local',
+                        supportsCloudAuth: false,
+                        supportsAdminManagedSetupOverrides: false,
+                        supportsPackageScriptSetupOverrides: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-library')) {
+                return jsonResponse({
+                    packs: [
+                        {
+                            id: 'general',
+                            label: 'General',
+                            description: 'Neutral starter pack.',
+                            isDefaultStarter: true,
+                            categories: [{ value: 'general', label: 'General', icon: 'Inbox', color: 'slate-400' }],
+                            types: [{ value: 'task', label: 'Task', icon: 'CheckSquare', color: 'blue-500' }],
+                            priorities: [{ value: 1, label: 'Low', icon: 'ArrowDown', color: 'amber-200' }]
+                        },
+                        {
+                            id: 'software-development',
+                            label: 'Software Development',
+                            description: 'Software starter pack.',
+                            categories: [{ value: 'engineering', label: 'Engineering', icon: 'Code', color: 'blue-500' }],
+                            types: [
+                                { value: 'feature', label: 'Feature', icon: 'Star', color: 'teal-500' },
+                                { value: 'bug', label: 'Bug', icon: 'Bug', color: 'red-500' }
+                            ],
+                            priorities: [
+                                { value: 1, label: 'Low', icon: 'ArrowDown', color: 'amber-200' },
+                                { value: 2, label: 'Medium', icon: 'Minus', color: 'yellow-500' },
+                                { value: 3, label: 'High', icon: 'ArrowUp', color: 'orange-500' },
+                                { value: 4, label: 'Critical', icon: 'AlertTriangle', color: 'red-500' }
+                            ]
+                        }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/workspace-profile')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                if (body?.name === 'Starter Workspace')
+                    workspaceSaved = true;
+                return jsonResponse({
+                    success: true,
+                    workspace: {
+                        id: 'workspace-starter-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/categories?workspaceId=workspace-starter-1')) {
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/types?workspaceId=workspace-starter-1')) {
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/priorities?workspaceId=workspace-starter-1')) {
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/ui-state')) {
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: mockTasks });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/workflow-templates')) {
+                return jsonResponse({ templates: [] });
+            }
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Workspace Setup Required')).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('radio', { name: /software development/i }));
+        await user.click(screen.getByRole('button', { name: 'Save Project Setup' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        const categoryApplyCall = fetchMock.mock.calls.find((call) => (String(call[0]).includes('/api/taskforce/categories?workspaceId=workspace-starter-1')
+            && String(call[1]?.method || '').toUpperCase() === 'POST'));
+        const typeApplyCall = fetchMock.mock.calls.find((call) => (String(call[0]).includes('/api/taskforce/types?workspaceId=workspace-starter-1')
+            && String(call[1]?.method || '').toUpperCase() === 'POST'));
+        const priorityApplyCall = fetchMock.mock.calls.find((call) => (String(call[0]).includes('/api/taskforce/priorities?workspaceId=workspace-starter-1')
+            && String(call[1]?.method || '').toUpperCase() === 'POST'));
+        expect(categoryApplyCall).toBeDefined();
+        expect(typeApplyCall).toBeDefined();
+        expect(priorityApplyCall).toBeDefined();
+        expect(new Headers(categoryApplyCall?.[1]?.headers).get('x-taskforce-workspace-id')).toBe('workspace-starter-1');
+        expect(new Headers(typeApplyCall?.[1]?.headers).get('x-taskforce-workspace-id')).toBe('workspace-starter-1');
+        expect(new Headers(priorityApplyCall?.[1]?.headers).get('x-taskforce-workspace-id')).toBe('workspace-starter-1');
+    });
+    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('creates a new cloud workspace only after guided setup submit', async () => {
+        const user = userEvent.setup();
+        let currentWorkspaceId = 'workspace-cloud-active';
+        let workspaceCreated = false;
+        const fetchMock = vi.fn((url, init) => {
+            const method = String(init?.method || 'GET').toUpperCase();
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'cloud', workspaceMode: 'multi-cloud', authSource: 'cloud' } });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-cloud',
+                    email: 'owner@example.com',
+                    workspaceId: currentWorkspaceId,
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: false,
+                    workspaceId: currentWorkspaceId,
+                    setupState: {
+                        globalSetupState: 'present',
+                        workspaceSetupState: 'present',
+                        runtimeMode: 'cloud',
+                        workspaceId: currentWorkspaceId,
+                        mode: 'core',
+                        forceSetup: false,
+                        forceGlobalSetup: false,
+                        forceWorkspaceSetup: false,
+                        workspace: {
+                            id: currentWorkspaceId,
+                            slug: currentWorkspaceId,
+                            name: currentWorkspaceId === 'workspace-cloud-new' ? 'Cloud New Project' : 'Cloud Active',
+                            description: currentWorkspaceId === 'workspace-cloud-new' ? 'New workspace description' : 'Active workspace'
+                        },
+                        suggestedWorkspaceName: ''
+                    },
+                    runtimeCapabilities: {
+                        runtimeMode: 'cloud',
+                        supportsCloudAuth: true,
+                        supportsAdminManagedSetupOverrides: true,
+                        supportsPackageScriptSetupOverrides: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-library')) {
+                return jsonResponse({
+                    packs: [{
+                            id: 'general',
+                            label: 'General',
+                            description: 'General starter',
+                            categories: [{ value: 'general', label: 'General' }],
+                            types: [{ value: 'task', label: 'Task' }],
+                            priorities: [
+                                { value: 1, label: 'Low' },
+                                { value: 2, label: 'Medium' },
+                                { value: 3, label: 'High' }
+                            ],
+                            isDefaultStarter: true
+                        }]
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces') && method === 'POST') {
+                workspaceCreated = true;
+                currentWorkspaceId = 'workspace-cloud-new';
+                return jsonResponse({
+                    success: true,
+                    workspace: {
+                        id: 'workspace-cloud-new',
+                        slug: 'workspace-cloud-new',
+                        name: 'Cloud New Project',
+                        description: 'New workspace description',
+                        role: 'owner'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId,
+                    workspaces: [
+                        { id: 'workspace-cloud-active', slug: 'workspace-cloud-active', name: 'Cloud Active', role: 'owner' },
+                        ...(workspaceCreated
+                            ? [{ id: 'workspace-cloud-new', slug: 'workspace-cloud-new', name: 'Cloud New Project', role: 'owner' }]
+                            : [])
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace') && method === 'POST') {
+                const body = JSON.parse(String(init?.body || '{}'));
+                currentWorkspaceId = String(body?.workspaceId || currentWorkspaceId);
+                return jsonResponse({ success: true, workspaceId: currentWorkspaceId });
+            }
+            if (url.includes('/api/taskforce/ui-state')) {
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse(mockCategories);
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return jsonResponse({ templates: [] });
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/setup?step=workspace&intent=create-workspace'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        await waitFor(() => {
+            expect(screen.getByText('Set up the new workspace before it is created.')).toBeInTheDocument();
+        });
+        await user.clear(screen.getByPlaceholderText('Project name'));
+        await user.type(screen.getByPlaceholderText('Project name'), 'Cloud New Project');
+        await user.clear(screen.getByPlaceholderText('Project description (optional)'));
+        await user.type(screen.getByPlaceholderText('Project description (optional)'), 'New workspace description');
+        await user.click(screen.getByRole('button', { name: 'Save Project Setup' }));
+        await waitFor(() => {
+            expect(workspaceCreated).toBe(true);
+        });
+        const createCall = fetchMock.mock.calls.find((call) => String(call[0]).includes('/api/taskforce/workspaces') && String(call[1]?.method || 'GET').toUpperCase() === 'POST');
+        const createBody = JSON.parse(String(createCall?.[1]?.body || '{}'));
+        expect(createBody.name).toBe('Cloud New Project');
+        expect(createBody.description).toBe('New workspace description');
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/workspace-profile'))).toBe(false);
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/bulk-update-fields'))).toBe(false);
+        const typeApplyCall = fetchMock.mock.calls.find((call) => (String(call[0]).includes('/api/taskforce/types?workspaceId=workspace-cloud-new')
+            && String(call[1]?.method || '').toUpperCase() === 'POST'));
+        const typeApplyBody = JSON.parse(String(typeApplyCall?.[1]?.body || '{}'));
+        expect(typeApplyBody.types).toEqual([{ value: 'task', label: 'Task' }]);
+        await waitFor(() => {
+            expect(screen.getByTitle('Workspace ID: workspace-cloud-new')).toBeInTheDocument();
+        });
+    });
+    it('cancels voluntary cloud workspace creation back to the active workspace', async () => {
+        const user = userEvent.setup();
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'cloud', workspaceMode: 'multi-cloud', authSource: 'cloud' } });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: false,
+                    userId: 'user-cloud',
+                    email: 'owner@example.com',
+                    workspaceId: 'workspace-cloud-active',
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...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: 'Active workspace'
+                        },
+                        suggestedWorkspaceName: ''
+                    },
+                    runtimeCapabilities: {
+                        runtimeMode: 'cloud',
+                        supportsCloudAuth: true,
+                        supportsAdminManagedSetupOverrides: true,
+                        supportsPackageScriptSetupOverrides: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/taxonomy-library')) {
+                return jsonResponse({
+                    packs: [{
+                            id: 'general',
+                            label: 'General',
+                            description: 'General starter',
+                            categories: [{ value: 'general', label: 'General' }],
+                            types: [{ value: 'task', label: 'Task' }],
+                            priorities: [{ value: 1, label: 'Low' }],
+                            isDefaultStarter: true
+                        }]
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: 'workspace-cloud-active',
+                    workspaces: [
+                        { id: 'workspace-cloud-active', slug: 'workspace-cloud-active', name: 'Cloud Active', role: 'owner' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse(mockCategories);
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return jsonResponse({ templates: [] });
+            if (url.includes('/api/taskforce/ui-state'))
+                return jsonResponse({ success: true });
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/setup?step=workspace&intent=create-workspace'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        await waitFor(() => {
+            expect(screen.getByText('Set up the new workspace before it is created.')).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('button', { name: 'Cancel' }));
+        await waitFor(() => {
+            expect(screen.getByTitle('Workspace ID: workspace-cloud-active')).toBeInTheDocument();
+        });
+        expect(screen.queryByText('Set up the new workspace before it is created.')).not.toBeInTheDocument();
+    });
+    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'
-                        })
-                    });
-                }
+            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: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/documents'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            if (url.includes('/api/taskforce/sync/user-settings'))
+                return jsonResponse({ settings: {}, updatedAt: '2026-03-15T14:28:16.000Z' });
+            if (url.includes('/api/taskforce/sync/workspace/handshake'))
+                return jsonResponse({ success: true });
+            if (url.includes('/api/taskforce/sync/workspace/pull'))
+                return jsonResponse({ success: true, changes: [], hasMore: false, nextCursor: null });
+            if (url.includes('/api/taskforce/sync/workspace/push'))
+                return jsonResponse({ success: true, syncedAt: '2026-03-15T14:28:16.000Z' });
+            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('keeps workspace management cloud-only while allowing cloud-backed team management from local runtime', () => {
+        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).toContain("const canManageCloudWorkspaces = runtimeMode === 'cloud' && workspaceSwitchingEnabled && isAuthenticated;");
+        expect(standaloneLayoutSource).toContain("const canAccessCloudTeamManagement = isAuthenticated && (runtimeMode === 'cloud' || cloudAuthConfigured);");
+        expect(standaloneLayoutSource).toContain("const teamManagementWorkspaceId = String(authWorkspaceId || currentWorkspaceId || '').trim();");
+        expect(standaloneLayoutSource).toContain('computeCanOpenTeamManagement(canAccessCloudTeamManagement, currentWorkspaceRole, teamPlanMode)');
+        expect(useTaskforceSource).toContain("const [authWorkspaceId, setAuthWorkspaceId] = useState<string>('');");
+    });
+    it('routes local plans and billing UI through the connected cloud billing base', () => {
+        const standaloneLayoutPath = path.join(process.cwd(), 'src/components/views/StandaloneLayout.tsx');
+        const standaloneLayoutSource = fs.readFileSync(standaloneLayoutPath, 'utf8');
+        expect(standaloneLayoutSource).toContain("const billingApiBaseUrl = useMemo(() => {");
+        expect(standaloneLayoutSource).toContain("const res = await fetch(buildBillingApiUrl('/api/taskforce/billing/status'), {");
+        expect(standaloneLayoutSource).toContain("apiBaseUrl={billingApiBaseUrl}");
+    });
+    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('resolveClientDeploymentConfig');
+        expect(appMainSource).toContain('return undefined;');
+    });
+    it('passes runtime mode and raw api config through to the document workspace shell', () => {
+        const standaloneLayoutPath = path.join(process.cwd(), 'src/components/views/StandaloneLayout.tsx');
+        const standaloneLayoutSource = fs.readFileSync(standaloneLayoutPath, 'utf8');
+        const docsShellMatch = standaloneLayoutSource.match(/<DocumentWorkspaceShell[\s\S]*?\/>/);
+        const docsShellSource = docsShellMatch?.[0] || '';
+        expect(docsShellSource).toContain("runtimeMode={runtimeMode}");
+        expect(docsShellSource).toContain("apiBaseUrl={props.config?.apiBaseUrl || ''}");
+        expect(docsShellSource).toContain("cloudAuthBaseUrl={props.config?.cloudAuthBaseUrl || ''}");
+    });
+    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 focuses on the lean summary instead of internal sync fields', 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: {
+                            version: 2,
+                            enabled: true,
+                            phase: 'active',
+                            pullCursor: null,
+                            lastPullAt: '2026-03-15T14:28:16.000Z',
+                            lastPushAt: '2026-03-15T14:28:16.000Z',
+                            lastSyncedAt: '2026-03-15T14:28:16.000Z'
+                        }
+                    })
+                });
+            }
+            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(/Sync manager:/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Sync manager:/i));
+        await waitFor(() => {
+            expect(screen.getByText('Sync Manager')).toBeInTheDocument();
+            const dialog = screen.getByText('Sync Manager').closest(`.${modalStyles.modal}`);
+            expect(within(dialog).getByText('Status')).toBeInTheDocument();
+            expect(within(dialog).getByText('Summary')).toBeInTheDocument();
+            expect(within(dialog).getByText('Last successful sync')).toBeInTheDocument();
+            expect(within(dialog).getByText('Last pull from cloud')).toBeInTheDocument();
+            expect(within(dialog).getByText('Last push to cloud')).toBeInTheDocument();
+            expect(within(dialog).getByText('Pending local changes')).toBeInTheDocument();
+            expect(within(dialog).getByText('Last error')).toBeInTheDocument();
+            expect(within(dialog).getByText('Recommended action')).toBeInTheDocument();
+            expect(within(dialog).getByText('Local sync diagnostics')).toBeInTheDocument();
+            expect(within(dialog).getByText('Recent sync events')).toBeInTheDocument();
+            expect(within(dialog).queryByText('Sync enabled')).not.toBeInTheDocument();
+            expect(within(dialog).queryByText('Phase')).not.toBeInTheDocument();
+            expect(within(dialog).queryByText('Runtime mode')).not.toBeInTheDocument();
+            expect(within(dialog).queryByText('Sync source')).not.toBeInTheDocument();
+        });
+    });
+    it('sync status modal shows sync controls, bootstrap summary, and copy action', async () => {
+        const user = userEvent.setup();
+        const writeText = vi.fn().mockResolvedValue(undefined);
+        Object.defineProperty(navigator, 'clipboard', {
+            configurable: true,
+            value: { writeText }
+        });
+        const uiStatePosts = [];
+        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: {
+                            version: 2,
+                            enabled: true,
+                            phase: 'provision-local',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                uiStatePosts.push(JSON.parse(String(init?.body || '{}')));
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            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: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/documents'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            if (url.includes('/api/taskforce/sync/events')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        events: [
+                            {
+                                occurredAt: '2026-03-15T14:28:17.000Z',
+                                eventType: 'apply',
+                                status: 'error',
+                                errorMessage: 'Detected asset reference number mismatch during normal sync.',
+                                details: {
+                                    path: 'workspaces/workspace-local-active/assets/images/hero.png',
+                                    existingReferenceNumber: 12,
+                                    incomingReferenceNumber: 18
+                                }
+                            },
+                            {
+                                occurredAt: '2026-03-15T14:28:16.000Z',
+                                eventType: 'push',
+                                status: 'success',
+                                changeCount: 1,
+                                requestMs: 42
+                            }
+                        ]
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/sync/user-settings'))
+                return jsonResponse({ settings: {}, updatedAt: '2026-02-26T11:55:54.000Z' });
+            if (url.includes('/api/taskforce/sync/workspace/handshake'))
+                return jsonResponse({ success: true });
+            if (url.includes('/api/taskforce/sync/workspace/push'))
+                return new Promise(() => { });
+            if (url.includes('/api/taskforce/sync/workspace/pull'))
+                return jsonResponse({ changes: [], nextCursor: null, hasMore: false });
+            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(/Sync manager:/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Sync manager:/i));
+        await screen.findByText('Sync Manager');
+        const dialog = screen.getByText('Sync Manager').closest(`.${modalStyles.modal}`);
+        expect(within(dialog).getByText('Current Session')).toBeInTheDocument();
+        expect(within(dialog).getByText('Activity')).toBeInTheDocument();
+        expect(within(dialog).getByText(/first upload to cloud/i)).toBeInTheDocument();
+        expect(within(dialog).getByRole('switch', { name: 'Enable Sync' })).toBeChecked();
+        expect(within(dialog).getByRole('button', { name: 'Copy Report' })).toBeInTheDocument();
+        expect(within(dialog).getByText('AI profile snapshot')).toBeInTheDocument();
+        expect(within(dialog).getByText('Last pushed AI profiles')).toBeInTheDocument();
+        expect(within(dialog).getByText(/push succeeded \(1 change\) in 42ms/i)).toBeInTheDocument();
+        expect(within(dialog).getByText('Identifier Integrity')).toBeInTheDocument();
+        expect(within(dialog).getByText('workspaces/workspace-local-active/assets/images/hero.png')).toBeInTheDocument();
+        expect(within(dialog).getByText('Existing 12 vs incoming 18')).toBeInTheDocument();
+        expect(within(dialog).queryByText('Current Status')).not.toBeInTheDocument();
+        expect(within(dialog).queryByRole('button', { name: 'Repair' })).toBeInTheDocument();
+        await user.click(within(dialog).getByRole('button', { name: 'Copy Report' }));
+        await waitFor(() => {
+            expect(writeText).toHaveBeenCalledTimes(1);
+        });
+        expect(String(writeText.mock.calls[0][0])).toContain('Workspace ID: workspace-local-active');
+        expect(String(writeText.mock.calls[0][0])).toContain('Summary:');
+        expect(String(writeText.mock.calls[0][0])).not.toContain('Sync enabled:');
+        expect(String(writeText.mock.calls[0][0])).toContain('Sync stage: Initial cloud upload');
+        expect(String(writeText.mock.calls[0][0])).toContain('Recent sync events');
+        expect(String(writeText.mock.calls[0][0])).toContain('AI profile snapshot:');
+        expect(String(writeText.mock.calls[0][0])).toContain('2026-03-15T14:28:16.000Z push succeeded (1 change) in 42ms');
+        await user.click(within(dialog).getByRole('switch', { name: 'Enable Sync' }));
+        await waitFor(() => {
+            expect(uiStatePosts.some((entry) => entry?.patch?.enabled === false)).toBe(true);
+        });
+    });
+    it('sync status modal shows active cloud apply instead of synced during cloud bootstrap', 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({
-                        success: true,
-                        localWorkspaceId: 'workspace-local-flow-1',
-                        cloudWorkspaceId: 'workspace-local-flow-1'
+                        authenticated: true,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false
                     })
                 });
             }
-            if (url.includes('/api/taskforce/sync/workspace/provision')) {
-                cloudWorkspaceCreated = true;
+            if (url.includes('/api/taskforce/config')) {
                 return Promise.resolve({
                     ok: true,
-                    status: 201,
                     json: () => Promise.resolve({
-                        success: true,
-                        existing: false,
-                        workspace: { id: 'workspace-local-flow-1', name: 'Local Flow Project' }
+                        ...mockConfig,
+                        runtimeMode: 'local',
+                        authRequiredForApi: false,
+                        workspaceId: 'workspace-local-active'
                     })
                 });
             }
-            if (url.includes('/api/taskforce/sync/workspace/pull')) {
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
                         success: true,
-                        workspaceId: 'workspace-local-flow-1',
-                        changes: [],
-                        nextCursor: '',
-                        hasMore: false
+                        state: {
+                            version: 2,
+                            enabled: true,
+                            phase: 'attach-cloud',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
+                        }
                     })
                 });
             }
-            if (url.includes('/api/taskforce/sync/workspace/push')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            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 }) });
+                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/types'))
@@ -1084,71 +3639,39 @@ describe('TaskforceCore Integration', () => {
                 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/sync/workspace/documents'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            if (url.includes('/api/taskforce/sync/user-settings'))
+                return jsonResponse({ settings: {}, updatedAt: '2026-02-26T11:55:54.000Z' });
+            if (url.includes('/api/taskforce/sync/workspace/handshake'))
+                return jsonResponse({ success: true });
+            if (url.includes('/api/taskforce/sync/workspace/pull'))
+                return new Promise(() => { });
             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' } }) }));
+        render(_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(screen.getByTitle(/Sync manager:/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;');
+        await user.click(screen.getByTitle(/Sync manager:/i));
+        await screen.findByText('Sync Manager');
+        const dialog = screen.getByText('Sync Manager').closest(`.${modalStyles.modal}`);
+        expect(within(dialog).getByText(/cloud workspace into this device/i)).toBeInTheDocument();
+        expect(within(dialog).getAllByText('Syncing').length).toBeGreaterThan(0);
+        expect(within(dialog).queryByText('Healthy')).not.toBeInTheDocument();
     });
-    it('keeps local-only runtime behavior when signed out (no workspace cloud pull calls)', async () => {
-        const fetchMock = vi.fn((url) => {
+    it('keeps stale legacy cloud-first sync state in attach-cloud until a pull completes', async () => {
+        const user = userEvent.setup();
+        const uiStatePosts = [];
+        const fetchMock = vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        authenticated: false,
+                        authenticated: true,
                         runtimeMode: 'local',
                         authRequiredForApi: false
                     })
@@ -1173,12 +3696,22 @@ describe('TaskforceCore Integration', () => {
                         state: {
                             cloudSyncEnabled: true,
                             sourceOfTruth: 'cloud',
-                            onboardingCompleted: true,
-                            pullCursor: ''
+                            onboardingCompleted: false,
+                            pullCursor: '',
+                            lastPullAt: null,
+                            lastPushAt: '2026-03-15T14:28:16.000Z',
+                            lastSyncedAt: '2026-03-15T14:28:16.000Z'
                         }
                     })
                 });
             }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                uiStatePosts.push(JSON.parse(String(init?.body || '{}')));
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            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'))
@@ -1195,21 +3728,31 @@ describe('TaskforceCore Integration', () => {
                 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/sync/workspace/documents'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            if (url.includes('/api/taskforce/sync/user-settings'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ settings: {}, updatedAt: '2026-03-15T14:28:16.000Z' }) });
             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();
+            expect(screen.getByTitle(/Sync manager:/i)).toBeInTheDocument();
         });
+        await user.click(screen.getByTitle(/Sync manager:/i));
+        await screen.findByText('Sync Manager');
+        const dialog = screen.getByText('Sync Manager').closest(`.${modalStyles.modal}`);
+        expect(within(dialog).getAllByText('3/15/2026, 11:28:16 AM').length).toBeGreaterThan(0);
+        expect(within(dialog).queryByText('Sync source')).not.toBeInTheDocument();
+        expect(within(dialog).getByText('attach-cloud')).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);
+            expect(uiStatePosts.some((entry) => entry?.patch?.version === 2 && entry?.patch?.phase === 'attach-cloud')).toBe(true);
         });
-        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 () => {
+    it('sync status modal uses workspace sync timestamps instead of user-global sync timestamps', async () => {
+        const user = userEvent.setup();
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
@@ -1238,14 +3781,20 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         success: true,
                         state: {
-                            cloudSyncEnabled: false,
-                            sourceOfTruth: 'cloud',
-                            onboardingCompleted: true,
-                            pullCursor: ''
+                            version: 2,
+                            enabled: true,
+                            phase: 'active',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: '2026-03-15T14:28:16.000Z',
+                            lastSyncedAt: '2026-03-15T14:28:16.000Z'
                         }
                     })
                 });
             }
+            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'))
@@ -1262,22 +3811,36 @@ describe('TaskforceCore Integration', () => {
                 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/sync/workspace/documents'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            if (url.includes('/api/taskforce/sync/user-settings')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ settings: {}, updatedAt: '2026-02-26T11:55:54.000Z' }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/handshake')) {
+                return jsonResponse({ 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(/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);
+            expect(screen.getByTitle(/Sync manager:/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);
+        await user.click(screen.getByTitle(/Sync manager:/i));
+        await screen.findByText('Sync Manager');
+        const dialog = screen.getByText('Sync Manager').closest(`.${modalStyles.modal}`);
+        expect(within(dialog).getAllByText('3/15/2026, 11:28:16 AM').length).toBeGreaterThan(0);
+        expect(within(dialog).queryByText('2/26/2026, 7:55:54 AM')).not.toBeInTheDocument();
     });
-    it('does not repeatedly reload workspace-sync ui-state on equivalent rerenders', async () => {
-        let workspaceSyncReads = 0;
+    it('sync status modal shows a recommended action for attach-cloud bootstrap', async () => {
+        const user = userEvent.setup();
+        const writeText = vi.fn().mockResolvedValue(undefined);
+        Object.defineProperty(navigator, 'clipboard', {
+            configurable: true,
+            value: { writeText }
+        });
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
@@ -1301,16 +3864,18 @@ describe('TaskforceCore Integration', () => {
                 });
             }
             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: ''
+                            version: 2,
+                            enabled: true,
+                            phase: 'attach-cloud',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
                         }
                     })
                 });
@@ -1334,33 +3899,72 @@ describe('TaskforceCore Integration', () => {
                 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/sync/workspace/documents'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            if (url.includes('/api/taskforce/sync/events')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        events: [
+                            {
+                                occurredAt: '2026-03-15T14:28:16.000Z',
+                                eventType: 'pull',
+                                status: 'success',
+                                changeCount: 1,
+                                requestMs: 35
+                            }
+                        ]
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/sync/user-settings'))
+                return jsonResponse({ settings: {}, updatedAt: '2026-03-15T14:28:16.000Z' });
+            if (url.includes('/api/taskforce/sync/workspace/pull'))
+                return new Promise(() => { });
+            if (url.includes('/api/taskforce/sync/workspace/push'))
+                return jsonResponse({ success: true, syncedAt: '2026-03-15T14:28:16.000Z' });
+            if (url.includes('/api/taskforce/sync/workspace/handshake'))
+                return jsonResponse({ success: true });
             return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
         });
         vi.stubGlobal('fetch', fetchMock);
-        const { rerender } = render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
         await waitFor(() => {
-            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+            expect(screen.getByTitle(/Sync manager:/i)).toBeInTheDocument();
         });
+        await user.click(screen.getByTitle(/Sync manager:/i));
+        await screen.findByText('Sync Manager');
+        const dialog = screen.getByText('Sync Manager').closest(`.${modalStyles.modal}`);
+        expect(within(dialog).getByText('Sync stage')).toBeInTheDocument();
+        expect(within(dialog).getByText('Recommended action')).toBeInTheDocument();
+        expect(within(dialog).getByText(/Keep this window open for the first cloud pull/i)).toBeInTheDocument();
+        await user.click(within(dialog).getByRole('button', { name: 'Copy Report' }));
         await waitFor(() => {
-            expect(workspaceSyncReads).toBeGreaterThan(0);
+            expect(writeText).toHaveBeenCalledTimes(1);
         });
-        const baselineReads = workspaceSyncReads;
-        rerender(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
-        await new Promise((resolve) => window.setTimeout(resolve, 150));
-        expect(workspaceSyncReads).toBe(baselineReads);
+        expect(String(writeText.mock.calls[0][0])).toContain('Sync stage: Initial cloud pull');
+        expect(String(writeText.mock.calls[0][0])).toContain('Recommended action: Keep this window open for the first cloud pull. If it does not move, press Repair.');
+        expect(String(writeText.mock.calls[0][0])).toContain('Recent sync events');
+        expect(String(writeText.mock.calls[0][0])).toContain('2026-03-15T14:28:16.000Z pull succeeded (1 change) in 35ms');
     });
-    it('sync status modal displays runtime mode and sync source of truth separately', async () => {
-        const user = userEvent.setup();
+    it('waits for auth session resolution before starting background workspace pull sync', async () => {
+        let resolveSession;
+        const sessionGate = new Promise((resolve) => {
+            resolveSession = resolve;
+        });
+        let pullCallCount = 0;
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/session')) {
-                return Promise.resolve({
+                return sessionGate.then(() => ({
                     ok: true,
                     json: () => Promise.resolve({
                         authenticated: true,
                         runtimeMode: 'local',
                         authRequiredForApi: false
                     })
-                });
+                }));
             }
             if (url.includes('/api/taskforce/config')) {
                 return Promise.resolve({
@@ -1379,10 +3983,13 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         success: true,
                         state: {
-                            cloudSyncEnabled: true,
-                            sourceOfTruth: 'cloud',
-                            onboardingCompleted: true,
-                            pullCursor: ''
+                            version: 2,
+                            enabled: true,
+                            phase: 'attach-cloud',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
                         }
                     })
                 });
@@ -1406,19 +4013,35 @@ describe('TaskforceCore Integration', () => {
                 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/sync/workspace/documents'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments'))
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
+            if (url.includes('/api/taskforce/sync/user-settings'))
+                return jsonResponse({ settings: {}, updatedAt: '2026-03-18T12:00:00.000Z' });
+            if (url.includes('/api/taskforce/sync/workspace/handshake'))
+                return jsonResponse({ success: true });
+            if (url.includes('/api/taskforce/sync/workspace/pull')) {
+                pullCallCount += 1;
+                return jsonResponse({ success: true, changes: [], hasMore: false, nextCursor: null });
+            }
             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();
+            expect(screen.getByText('Test Project')).toBeInTheDocument();
+        });
+        await new Promise((resolve) => window.setTimeout(resolve, 200));
+        expect(pullCallCount).toBe(0);
+        expect(screen.queryByText('Authentication required. Sign in to continue.')).not.toBeInTheDocument();
+        await act(async () => {
+            if (resolveSession)
+                resolveSession();
+            await Promise.resolve();
         });
-        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();
+            expect(pullCallCount).toBeGreaterThan(0);
         });
     });
     it('uses apply-local route with workspace header when cloud pull merges into local workspace', async () => {
@@ -1426,8 +4049,7 @@ describe('TaskforceCore Integration', () => {
         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';");
+        expect(cloudSyncApiSource).not.toContain("/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');
@@ -1529,7 +4151,7 @@ describe('TaskforceCore Integration', () => {
         vi.stubGlobal('fetch', fetchMock);
         render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
         await waitFor(() => {
-            expect(screen.getByTitle(/Cloud sync status:/i)).toBeInTheDocument();
+            expect(screen.getByTitle(/Sync manager:/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);
@@ -1641,7 +4263,7 @@ describe('TaskforceCore Integration', () => {
             expect(screen.getByText('0/0')).toBeInTheDocument();
         });
     });
-    it.skip('retries pull automatically after transient cloud failure and applies changes on reconnect', async () => {
+    it('retries pull automatically after transient cloud failure and applies changes on reconnect', async () => {
         const cloudTask = {
             id: 'task-retry-reconnect-1',
             title: 'Recovered after retry',
@@ -1711,25 +4333,22 @@ describe('TaskforceCore Integration', () => {
                 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('/api/taskforce/sync/workspace/handshake')) {
+                return jsonResponse({ success: true });
             }
-            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+            if (url.includes('/api/taskforce/sync/workspace/pull')) {
                 pullAttempt += 1;
                 if (pullAttempt === 1) {
-                    return Promise.resolve({ ok: false, status: 503, json: () => Promise.resolve({ error: 'unavailable' }) });
+                    return jsonResponse({ error: 'unavailable' }, 503);
                 }
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        success: true,
-                        changes: [{ op: 'upsert', archived: false, task: cloudTask }],
-                        nextCursor: 'cursor-retry-success',
-                        hasMore: false
-                    })
+                return jsonResponse({
+                    success: true,
+                    changes: [{ op: 'upsert', archived: false, task: cloudTask }],
+                    nextCursor: 'cursor-retry-success',
+                    hasMore: false
                 });
             }
-            if (url === '/api/taskforce/sync/workspace/apply-local') {
+            if (url.includes('/api/taskforce/sync/workspace/apply-local')) {
                 return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
             }
             if (url.includes('/api/taskforce/ui-state'))
@@ -1751,7 +4370,7 @@ describe('TaskforceCore Integration', () => {
             expect(applyCalls.length).toBeGreaterThanOrEqual(1);
         }, { timeout: 5000 });
     });
-    it.skip('retries pull automatically after transient apply-local failures and recovers', async () => {
+    it('retries pull automatically after transient apply-local failures and recovers', async () => {
         const cloudTask = {
             id: 'task-retry-apply-failure-1',
             title: 'Apply retry recovered',
@@ -1816,22 +4435,19 @@ describe('TaskforceCore Integration', () => {
                 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('/api/taskforce/sync/workspace/handshake')) {
+                return jsonResponse({ success: true });
             }
-            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+            if (url.includes('/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
-                    })
+                return jsonResponse({
+                    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') {
+            if (url.includes('/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' }) });
@@ -1944,12 +4560,12 @@ describe('TaskforceCore Integration', () => {
             expect(pullUrls.length).toBeGreaterThan(0);
         });
         expect(pullUrls[0]).toContain('cursor=cursor-existing');
-        await user.click(screen.getByTitle(/Cloud sync status:/i));
+        await user.click(screen.getByTitle(/Sync manager:/i));
         await waitFor(() => {
-            expect(screen.getByRole('button', { name: 'Reset Cursor + Full Pull' })).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Repair' })).toBeInTheDocument();
         });
         const pullCountBeforeReset = pullUrls.length;
-        await user.click(screen.getByRole('button', { name: 'Reset Cursor + Full Pull' }));
+        await user.click(screen.getByRole('button', { name: 'Repair' }));
         await waitFor(() => {
             expect(pullUrls.length).toBeGreaterThan(pullCountBeforeReset);
         });
@@ -2129,4 +4745,117 @@ describe('TaskforceCore Integration', () => {
             expect(screen.getByTitle('Workspace ID: workspace-cloud-active')).toBeInTheDocument();
         });
     });
+    it('opens edit profile from the account menu and saves the updated display name', async () => {
+        const user = userEvent.setup();
+        let savedDisplayName = 'Original Name';
+        const fetchMock = vi.fn((input, init) => {
+            const url = String(input);
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    runtimeMode: 'local',
+                    authRequiredForApi: false,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    displayName: savedDisplayName,
+                    workspaceId: 'workspace-local-active'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app')) {
+                return jsonResponse({ success: true, state: {} });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: {
+                        version: 2,
+                        enabled: false,
+                        phase: 'idle',
+                        pullCursor: null,
+                        lastPullAt: null,
+                        lastPushAt: null,
+                        lastSyncedAt: null
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...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 jsonResponse(mockCategories);
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return jsonResponse({ templates: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ options: [] });
+            if (url.includes('/api/taskforce/auth/profile')) {
+                const body = JSON.parse(String(init?.body || '{}'));
+                savedDisplayName = String(body?.displayName || '').trim() || savedDisplayName;
+                return jsonResponse({
+                    success: true,
+                    profile: {
+                        userId: 'user-1',
+                        email: 'user@example.com',
+                        displayName: savedDisplayName
+                    }
+                });
+            }
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        await user.click(await screen.findByRole('menuitem', { name: 'Edit Profile' }));
+        const dialog = await screen.findByText('Edit Profile');
+        const modal = dialog.closest(`.${modalStyles.modal}`);
+        expect(within(modal).getByDisplayValue('Original Name')).toBeInTheDocument();
+        expect(within(modal).getByDisplayValue('user@example.com')).toBeDisabled();
+        const displayNameInput = within(modal).getByPlaceholderText('Display name');
+        await user.clear(displayNameInput);
+        await user.type(displayNameInput, 'Updated Name');
+        await user.click(within(modal).getByRole('button', { name: 'Save Profile' }));
+        await waitFor(() => {
+            const profileCall = fetchMock.mock.calls.find((call) => String(call[0]).includes('/api/taskforce/auth/profile'));
+            expect(profileCall).toBeTruthy();
+            const payload = JSON.parse(String(profileCall?.[1]?.body || '{}'));
+            expect(payload.displayName).toBe('Updated Name');
+        });
+        await waitFor(() => {
+            expect(screen.queryByText('Edit Profile')).not.toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        expect(await screen.findByText('Updated Name')).toBeInTheDocument();
+    });
 });