@taskforcehq/taskforce 0.3.301 → 0.3.303

package/dist/TaskforceCore.test.js

@@ -48,9 +48,10 @@ function jsonResponse(body, status = 200) {
 describe('TaskforceCore Integration', () => {
     beforeEach(() => {
         localStorage.clear();
+        sessionStorage.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' } }) });
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } }) });
             }
             if (url.includes('/api/taskforce/ui-state?key=app')) {
                 return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: {} }) });
@@ -168,7 +169,7 @@ describe('TaskforceCore Integration', () => {
     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' } }) });
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } }) });
             }
             if (url.includes('/api/taskforce/ui-state?key=app')) {
                 return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: {} }) });
@@ -1037,7 +1038,7 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            if (url.includes('/api/taskforce/billing/status')) {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
@@ -1047,7 +1048,7 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            if (url.includes('/api/taskforce/billing/status')) {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
@@ -1143,7 +1144,7 @@ describe('TaskforceCore Integration', () => {
                         hasEntitlement: false,
                         canAccessApp: false,
                         canAccessPlans: true,
-                        message: 'Signup monetization is misconfigured.'
+                        message: 'Onboarding policy is misconfigured.'
                     })
                 });
             }
@@ -1196,7 +1197,7 @@ describe('TaskforceCore Integration', () => {
         render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, {}) }));
         await waitFor(() => {
             expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-            expect(screen.getByText('Signup monetization is misconfigured. Contact support or a system administrator.')).toBeInTheDocument();
+            expect(screen.getByText('Onboarding policy is misconfigured. Contact support or a system administrator.')).toBeInTheDocument();
         });
     });
     it('suppresses stale missing-entitlement gate messaging when billing status is already active', async () => {
@@ -1287,7 +1288,7 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            if (url.includes('/api/taskforce/billing/status')) {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
@@ -1388,7 +1389,7 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            if (url.includes('/api/taskforce/billing/status')) {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
@@ -1445,7 +1446,7 @@ describe('TaskforceCore Integration', () => {
         await waitFor(() => {
             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);
+            expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/account/profile-summary'))).toBe(true);
         });
         await waitFor(() => {
             expect(screen.getByText('Subscription')).toBeInTheDocument();
@@ -1507,7 +1508,7 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            if (url.includes('/api/taskforce/billing/status')) {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
@@ -1569,7 +1570,293 @@ describe('TaskforceCore Integration', () => {
             expect(screen.getByText('CLOUD.EXAMPLE.COM')).toBeInTheDocument();
         });
     }, 10000);
-    it('allows local runtime to open shared /login and register flow', async () => {
+    it('preserves the original user billing and team access after registering and switching back in local runtime', async () => {
+        const user = userEvent.setup();
+        const accounts = {
+            ross: {
+                email: 'ross.burke@gmail.com',
+                userId: 'user-ross',
+                displayName: 'Ross Burke',
+                workspaceId: 'workspace-local-active',
+                planId: 'team-5',
+                planVersionId: 'team-5-v1',
+                planName: 'Team 5',
+                teamManagementAllowed: true,
+                teamPlanMode: 'team',
+                workspaceRole: 'owner'
+            },
+            newcomer: {
+                email: 'new.user@example.com',
+                userId: 'user-new',
+                displayName: 'New User',
+                workspaceId: 'workspace-local-active',
+                planId: 'starter',
+                planVersionId: 'starter-v1',
+                planName: 'Starter',
+                teamManagementAllowed: false,
+                teamPlanMode: 'personal',
+                workspaceRole: 'member'
+            }
+        };
+        let currentAccountKey = 'ross';
+        const currentAccount = () => (currentAccountKey ? accounts[currentAccountKey] : null);
+        const fetchMock = vi.fn((input, init) => {
+            const url = String(input);
+            const account = currentAccount();
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    success: true,
+                    config: {
+                        baseUrl: 'https://cloud.example.com',
+                        apiBaseUrl: 'https://cloud.example.com',
+                        cloudAuthBaseUrl: 'https://cloud.example.com',
+                        runtimeMode: 'local',
+                        authSource: 'cloud',
+                        workspaceMode: 'single-local',
+                        workspaceSwitchingEnabled: false,
+                        cloudAuthViaLocalProxy: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: Boolean(account),
+                    runtimeMode: 'local',
+                    authRequiredForApi: false,
+                    email: account?.email || '',
+                    displayName: account?.displayName || '',
+                    userId: account?.userId || 'anonymous',
+                    workspaceId: account?.workspaceId || '',
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/auth/logout')) {
+                currentAccountKey = null;
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/auth/register')) {
+                currentAccountKey = 'newcomer';
+                return jsonResponse({
+                    success: true,
+                    workspaceSetupRequired: false,
+                    verificationRequired: false
+                });
+            }
+            if (url.includes('/api/taskforce/auth/login')) {
+                const body = typeof init?.body === 'string' ? JSON.parse(init.body) : {};
+                currentAccountKey = String(body?.email || '').trim().toLowerCase() === accounts.ross.email
+                    ? 'ross'
+                    : 'newcomer';
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return jsonResponse(account
+                    ? {
+                        planId: account.planId,
+                        planVersionId: account.planVersionId,
+                        planName: account.planName,
+                        entitlementState: 'active',
+                        workspaceId: account.workspaceId,
+                        workspaceRole: account.workspaceRole,
+                        canManageWorkspace: account.workspaceRole === 'owner' || account.workspaceRole === 'admin',
+                        teamPlanMode: account.teamPlanMode,
+                        teamManagementAllowed: account.teamManagementAllowed
+                    }
+                    : {
+                        planId: null,
+                        planVersionId: null,
+                        planName: null,
+                        entitlementState: null,
+                        workspaceId: 'workspace-local-active',
+                        workspaceRole: null,
+                        canManageWorkspace: false,
+                        teamPlanMode: 'unknown',
+                        teamManagementAllowed: false
+                    });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members')) {
+                return jsonResponse({
+                    users: account ? [{
+                            userId: account.userId,
+                            email: account.email,
+                            displayName: account.displayName,
+                            role: account.workspaceRole,
+                            status: 'active',
+                            disabled: false
+                        }] : []
+                });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return jsonResponse({
+                    plans: [
+                        {
+                            planId: 'starter',
+                            displayName: 'Starter',
+                            status: 'active',
+                            defaultVersion: {
+                                planVersionId: 'starter-v1',
+                                versionNumber: 1,
+                                seatLimit: null,
+                                metadata: {}
+                            },
+                            features: [],
+                            pricing: {
+                                month: { pricingType: 'free', stripePriceId: null, unitAmount: 0, currency: null, interval: 'month' },
+                                year: null
+                            }
+                        },
+                        {
+                            planId: 'team-5',
+                            displayName: 'Team 5',
+                            status: 'active',
+                            defaultVersion: {
+                                planVersionId: 'team-5-v1',
+                                versionNumber: 1,
+                                seatLimit: 5,
+                                metadata: {}
+                            },
+                            features: [],
+                            pricing: {
+                                month: { pricingType: 'stripe', stripePriceId: 'price_team_5_month', unitAmount: 5000, currency: 'usd', interval: 'month' },
+                                year: { pricingType: 'stripe', stripePriceId: 'price_team_5_year', unitAmount: 50000, currency: 'usd', interval: 'year' }
+                            }
+                        }
+                    ]
+                });
+            }
+            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/tasks')) {
+                return jsonResponse({ tasks: mockTasks });
+            }
+            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/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({ assignees: [] });
+            }
+            if (url.includes('/api/taskforce/initiatives')) {
+                return jsonResponse([]);
+            }
+            if (url.includes('/api/taskforce/workstreams')) {
+                return jsonResponse([]);
+            }
+            return jsonResponse({});
+        });
+        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));
+        await waitFor(() => {
+            expect(screen.getByText(accounts.ross.email)).toBeInTheDocument();
+            expect(screen.getByText('Team 5')).toBeInTheDocument();
+            expect(screen.getByRole('menuitem', { name: 'Team Management' })).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('menuitem', { name: 'Sign Out' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        await user.click(await screen.findByRole('menuitem', { name: 'Sign In / Register' }));
+        await waitFor(() => {
+            expect(screen.getByRole('button', { name: 'Register' })).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('button', { name: 'Register' }));
+        await user.type(await screen.findByPlaceholderText('Email'), accounts.newcomer.email);
+        await user.type(screen.getByPlaceholderText('Display name'), accounts.newcomer.displayName);
+        await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
+        await user.click(screen.getByRole('button', { name: 'Create Account' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        await waitFor(() => {
+            expect(screen.getByText(accounts.newcomer.email)).toBeInTheDocument();
+            expect(screen.getByText('Starter')).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('menuitem', { name: 'Sign Out' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        await user.click(await screen.findByRole('menuitem', { name: 'Sign In / Register' }));
+        await waitFor(() => {
+            expect(screen.getByText('Sign in with your account credentials.')).toBeInTheDocument();
+        });
+        await user.type(await screen.findByPlaceholderText('Email'), accounts.ross.email);
+        await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
+        await user.click(screen.getByRole('button', { name: 'Sign In' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        await waitFor(() => {
+            expect(screen.getByText(accounts.ross.email)).toBeInTheDocument();
+            expect(screen.getByText('Team 5')).toBeInTheDocument();
+            expect(screen.queryByText('Starter')).not.toBeInTheDocument();
+            expect(screen.getByRole('menuitem', { name: 'Team Management' })).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('button', { name: /Subscription Team 5/i }));
+        await waitFor(() => {
+            expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+        });
+        const currentPlanCard = screen.getByTestId('plan-card-team-5');
+        expect(within(currentPlanCard).getByTestId('plan-manage-team-5')).toHaveTextContent('Current Plan');
+    });
+    it('allows local runtime to open the shared cloud-backed register route', async () => {
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
@@ -1619,14 +1906,16 @@ describe('TaskforceCore Integration', () => {
         });
         expect(container.querySelector('[aria-pressed]')).not.toBeInTheDocument();
     });
-    it('shows debug registration autofill only when debug mode is enabled', async () => {
-        const fetchMock = vi.fn((url) => {
+    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',
+                        runtimeMode: 'cloud',
                         authRequiredForApi: false
                     })
                 });
@@ -1636,12 +1925,12 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         ...mockConfig,
-                        runtimeMode: 'local',
+                        runtimeMode: 'cloud',
                         authRequiredForApi: false,
                         setupState: {
                             globalSetupState: 'present',
                             workspaceSetupState: 'present',
-                            runtimeMode: 'local',
+                            runtimeMode: 'cloud',
                             workspaceId: 'workspace-local-active',
                             mode: 'core',
                             forceSetup: false,
@@ -1651,99 +1940,373 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            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: []
+                    })
+                });
+            }
+            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.getByText('Subscription Plans')).toBeInTheDocument();
+        });
+        expect(screen.queryByPlaceholderText('Verification token')).not.toBeInTheDocument();
+        expect(screen.queryByRole('button', { name: 'Create Account' })).not.toBeInTheDocument();
+    });
+    it('routes successful registration into plan selection when onboarding leaves the account pending plan selection', async () => {
+        const user = userEvent.setup();
+        let authenticated = false;
+        const fetchMock = vi.fn((input) => {
+            const url = String(input);
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        baseUrl: 'https://app.taskforce.example',
+                        apiBaseUrl: 'https://app.taskforce.example/api',
+                        cloudAuthBaseUrl: 'https://app.taskforce.example',
+                        runtimeMode: 'cloud',
+                        authSource: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        workspaceSwitchingEnabled: true,
+                        authRequiredForApi: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: authenticated ? 'user-1' : null,
+                    workspaceId: authenticated ? 'workspace-1' : null,
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    workspaceSwitchingEnabled: true,
+                    setupState: {
+                        globalSetupState: 'present',
+                        workspaceSetupState: 'present',
+                        runtimeMode: 'cloud',
+                        workspaceId: 'workspace-1',
+                        mode: 'core',
+                        forceSetup: false,
+                        forceGlobalSetup: false,
+                        forceWorkspaceSetup: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    workspaces: [{
+                            id: 'workspace-1',
+                            slug: 'workspace-1',
+                            name: 'Workspace 1',
+                            description: null,
+                            role: 'owner',
+                            status: 'active',
+                            betaAccess: true
+                        }],
+                    currentWorkspaceId: 'workspace-1'
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return jsonResponse({
+                    gate: 'plan_selection_required',
+                    hasEntitlement: true,
+                    canAccessApp: false,
+                    canAccessPlans: true,
+                    message: 'Choose a plan to continue.'
+                });
+            }
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return jsonResponse({
+                    entitlementState: 'pending_plan_selection',
+                    gate: 'plan_selection_required',
+                    message: 'Choose a plan to continue.',
+                    workspaceId: 'workspace-1'
+                });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return jsonResponse({
+                    plans: [{
+                            planId: 'starter',
+                            displayName: 'Starter',
+                            status: 'active',
+                            defaultVersion: {
+                                planVersionId: 'starter-v1',
+                                versionNumber: 1,
+                                seatLimit: null,
+                                metadata: {}
+                            },
+                            features: [],
+                            pricing: {
+                                month: {
+                                    planVersionId: 'starter-v1',
+                                    interval: 'month',
+                                    pricingType: 'free',
+                                    stripePriceId: 'free:starter-v1:month',
+                                    displayAmount: '$0.00',
+                                    unitAmount: 0,
+                                    currency: 'usd'
+                                },
+                                year: null
+                            }
+                        }]
+                });
+            }
+            if (url.includes('/api/taskforce/auth/register')) {
+                authenticated = true;
+                return jsonResponse({
+                    success: true,
+                    workspaceSetupRequired: false,
+                    verificationRequired: false,
+                    planSelectionRequired: true,
+                    commercialState: 'pending_plan_selection'
+                });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return jsonResponse(mockCategories);
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: mockTasks });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/data-version')) {
+                return jsonResponse({ dataVersion: 1 });
+            }
+            if (url.includes('/api/taskforce/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: [] });
+            }
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'pending@example.com');
+        await user.type(screen.getByPlaceholderText('Display name'), 'Pending User');
+        await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
+        await user.click(screen.getByRole('button', { name: 'Create Account' }));
+        await waitFor(() => {
+            expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+            expect(screen.getByText('Choose a plan to continue.')).toBeInTheDocument();
+        });
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/billing/checkout-session'))).toBe(false);
+    });
+    it('routes successful registration into checkout when onboarding leaves the account checkout-pending', async () => {
+        const user = userEvent.setup();
+        let authenticated = false;
+        const fetchMock = vi.fn((input) => {
+            const url = String(input);
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        baseUrl: 'https://app.taskforce.example',
+                        apiBaseUrl: 'https://app.taskforce.example/api',
+                        cloudAuthBaseUrl: 'https://app.taskforce.example',
+                        runtimeMode: 'cloud',
+                        authSource: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        workspaceSwitchingEnabled: true,
+                        authRequiredForApi: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: authenticated ? 'user-1' : null,
+                    workspaceId: authenticated ? 'workspace-1' : null,
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    workspaceSwitchingEnabled: true,
+                    setupState: {
+                        globalSetupState: 'present',
+                        workspaceSetupState: 'present',
+                        runtimeMode: 'cloud',
+                        workspaceId: 'workspace-1',
+                        mode: 'core',
+                        forceSetup: false,
+                        forceGlobalSetup: false,
+                        forceWorkspaceSetup: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    workspaces: [{
+                            id: 'workspace-1',
+                            slug: 'workspace-1',
+                            name: 'Workspace 1',
+                            description: null,
+                            role: 'owner',
+                            status: 'active',
+                            betaAccess: true
+                        }],
+                    currentWorkspaceId: 'workspace-1'
+                });
             }
-            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/account/access-status')) {
+                return jsonResponse({
+                    gate: 'checkout_pending',
+                    hasEntitlement: true,
+                    canAccessApp: false,
+                    canAccessPlans: true,
+                    message: 'Complete checkout to continue.'
                 });
             }
-            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/account/profile-summary')) {
+                return jsonResponse({
+                    planId: 'pro',
+                    planName: 'Pro',
+                    planVersionId: 'pro-v1',
+                    entitlementState: 'checkout_pending',
+                    gate: 'checkout_pending',
+                    message: 'Complete checkout to continue.',
+                    workspaceId: 'workspace-1'
                 });
             }
-            if (url.includes('/api/taskforce/workflow-templates')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return jsonResponse({
+                    plans: [{
+                            planId: 'pro',
+                            displayName: 'Pro',
+                            status: 'active',
+                            defaultVersion: {
+                                planVersionId: 'pro-v1',
+                                versionNumber: 1,
+                                seatLimit: null,
+                                metadata: {}
+                            },
+                            features: [],
+                            pricing: {
+                                month: {
+                                    planVersionId: 'pro-v1',
+                                    interval: 'month',
+                                    pricingType: 'stripe',
+                                    stripePriceId: 'price_pro_month',
+                                    displayAmount: '$19.00',
+                                    unitAmount: 1900,
+                                    currency: 'usd'
+                                },
+                                year: {
+                                    planVersionId: 'pro-v1',
+                                    interval: 'year',
+                                    pricingType: 'stripe',
+                                    stripePriceId: 'price_pro_year',
+                                    displayAmount: '$190.00',
+                                    unitAmount: 19000,
+                                    currency: 'usd'
+                                }
+                            }
+                        }]
+                });
             }
             if (url.includes('/api/taskforce/auth/register')) {
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        success: true,
-                        workspaceSetupRequired: false,
-                        verificationRequired: true,
-                        emailSent: true
-                    })
+                authenticated = true;
+                return jsonResponse({
+                    success: true,
+                    workspaceSetupRequired: false,
+                    verificationRequired: false,
+                    checkoutPending: true,
+                    commercialState: 'checkout_pending'
                 });
             }
-            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+            if (url.includes('/api/taskforce/billing/checkout-session')) {
+                return jsonResponse({
+                    checkoutState: 'updated',
+                    message: 'Checkout started.'
+                });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return jsonResponse(mockCategories);
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: mockTasks });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            if (url.includes('/api/taskforce/data-version')) {
+                return jsonResponse({ dataVersion: 1 });
+            }
+            if (url.includes('/api/taskforce/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: [] });
+            }
+            return jsonResponse({});
         });
         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!');
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&planId=pro&planVersionId=pro-v1&interval=year&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'checkout@example.com');
+        await user.type(screen.getByPlaceholderText('Display name'), 'Checkout User');
+        await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
         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();
+            expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+        });
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/billing/checkout-session'))).toBe(true);
+        });
     });
-    it('does not switch to verify mode after registration when verification is not required', async () => {
+    it('shows verification before workspace setup when registration still requires email verification', async () => {
         const user = userEvent.setup();
         const fetchMock = vi.fn((input) => {
             const url = String(input);
@@ -1752,8 +2315,8 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         authenticated: false,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
                     })
                 });
             }
@@ -1762,13 +2325,13 @@ 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,
@@ -1790,8 +2353,9 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         success: true,
-                        workspaceSetupRequired: false,
-                        verificationRequired: false
+                        workspaceSetupRequired: true,
+                        verificationRequired: true,
+                        emailSent: true
                     })
                 });
             }
@@ -1804,12 +2368,12 @@ describe('TaskforceCore Integration', () => {
         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.getByPlaceholderText('Verification token')).toBeInTheDocument();
         });
-        expect(screen.queryByPlaceholderText('Verification token')).not.toBeInTheDocument();
         expect(screen.queryByRole('button', { name: 'Create Account' })).not.toBeInTheDocument();
+        expect(screen.queryByText('Subscription Plans')).not.toBeInTheDocument();
     });
-    it('allows returning to sign-in/register from forgot mode', async () => {
+    it('allows returning to sign-in/register from forgot mode in local runtime', async () => {
         const user = userEvent.setup();
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/session')) {
@@ -1872,14 +2436,14 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         success: true,
                         config: {
-                            baseUrl: 'http://localhost:5174',
-                            apiBaseUrl: 'http://localhost:5174',
-                            cloudAuthBaseUrl: 'http://localhost:5174',
-                            runtimeMode: 'local',
+                            baseUrl: 'https://app.taskforce.example',
+                            apiBaseUrl: 'https://app.taskforce.example/api',
+                            cloudAuthBaseUrl: 'https://app.taskforce.example',
+                            runtimeMode: 'cloud',
                             authSource: 'cloud',
-                            workspaceMode: 'single-local',
-                            workspaceSwitchingEnabled: false,
-                            cloudAuthViaLocalProxy: true
+                            workspaceMode: 'multi-cloud',
+                            workspaceSwitchingEnabled: true,
+                            cloudAuthViaLocalProxy: false
                         }
                     })
                 });
@@ -1889,8 +2453,8 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         authenticated: false,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
                     })
                 });
             }
@@ -1899,12 +2463,12 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         ...mockConfig,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
                         setupState: {
                             globalSetupState: 'present',
                             workspaceSetupState: 'present',
-                            runtimeMode: 'local',
+                            runtimeMode: 'cloud',
                             workspaceId: 'workspace-local-active',
                             mode: 'core',
                             forceSetup: false,
@@ -1944,7 +2508,7 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         success: false,
                         code: 'SIGNUP_PLAN_NOT_ENABLED',
-                        error: 'Configured default signup plan version \"team-10-v1\" belongs to a disabled plan.'
+                        error: 'Configured onboarding plan version \"team-10-v1\" belongs to a disabled plan.'
                     })
                 });
             }
@@ -3078,13 +3642,20 @@ describe('TaskforceCore Integration', () => {
         });
         expect(cloudWorkspaceCreated).toBe(false);
     });
-    it('shows local runtime Sign In / Register action and routes to shared login', async () => {
+    it('shows local runtime Sign In 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('Sign In');
         expect(standaloneLayoutSource).toContain('openSharedLoginRoute(\'login\')');
         expect(standaloneLayoutSource).toContain('navigate(`/login?mode=${mode}&next=${encodeURIComponent(target)}`)');
     });
+    it('keeps the account badge neutral until the authenticated identity is fully resolved', () => {
+        const standaloneLayoutPath = path.join(process.cwd(), 'src/components/views/StandaloneLayout.tsx');
+        const standaloneLayoutSource = fs.readFileSync(standaloneLayoutPath, 'utf8');
+        expect(standaloneLayoutSource).toContain("const shouldShowResolvedAccountInitial = isAuthenticated && authSessionResolved && accountBadgeLabel.length > 0;");
+        expect(standaloneLayoutSource).toContain("const shouldShowResolvedAccountAvatar = isAuthenticated && authSessionResolved && accountAvatarUrl.length > 0;");
+        expect(standaloneLayoutSource).toContain('<User size={14} className={accountStyles.avatarIcon} />');
+    });
     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');
@@ -3092,16 +3663,25 @@ describe('TaskforceCore Integration', () => {
         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(standaloneLayoutSource).toContain("const teamManagementWorkspaceId = String(accountProfileSummary?.workspaceId || authWorkspaceId || currentWorkspaceId || '').trim();");
+        expect(standaloneLayoutSource).toContain("const accountProfileSummaryUrl = resolveCloudAuthUrl(ACCOUNT_PROFILE_SUMMARY_PATH);");
+        expect(standaloneLayoutSource).toContain('computeCanOpenTeamManagement(canAccessCloudTeamManagement, teamWorkspaceRole, 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}");
+        const plansPagePath = path.join(process.cwd(), 'src/components/views/PlansPage.tsx');
+        const plansPageSource = fs.readFileSync(plansPagePath, 'utf8');
+        const useTaskforcePath = path.join(process.cwd(), 'src/hooks/useTaskforce.ts');
+        const useTaskforceSource = fs.readFileSync(useTaskforcePath, 'utf8');
+        expect(standaloneLayoutSource).toContain("const accountProfileSummaryUrl = resolveCloudAuthUrl(ACCOUNT_PROFILE_SUMMARY_PATH);");
+        expect(standaloneLayoutSource).toContain("resolveCloudAuthUrl('/api/taskforce/billing/portal-session')");
+        expect(standaloneLayoutSource).toContain("resolveCloudAuthUrl={resolveCloudAuthUrl}");
+        expect(plansPageSource).toContain('const buildCloudBillingUrl = useCallback((path: string): string => {');
+        expect(plansPageSource).toContain("const accountProfileSummaryUrl = buildCloudBillingUrl(ACCOUNT_PROFILE_SUMMARY_PATH);");
+        expect(useTaskforceSource).toContain("|| path.startsWith('/api/taskforce/account/')");
+        expect(useTaskforceSource).toContain("|| path.startsWith('/api/taskforce/billing/')");
     });
     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');
@@ -3125,6 +3705,8 @@ describe('TaskforceCore Integration', () => {
         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(useTaskforceSource).toContain('const preferredCloudAuthBaseUrl = isLoopbackHost');
+        expect(useTaskforceSource).toContain("? (runtimeResolvedCloudAuthBaseUrl || explicitConfiguredCloudAuthBaseUrl)");
         expect(appMainSource).toContain('resolveClientDeploymentConfig');
         expect(appMainSource).toContain('return undefined;');
     });
@@ -3204,6 +3786,110 @@ describe('TaskforceCore Integration', () => {
         const pullCalls = fetchMock.mock.calls.filter((call) => typeof call[0] === 'string' && String(call[0]).includes('/sync/workspace/pull'));
         expect(pullCalls.length).toBe(0);
     });
+    it('keeps local workspace data loaded after signing out from the account menu', async () => {
+        const user = userEvent.setup();
+        let signedIn = true;
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: signedIn,
+                    runtimeMode: 'local',
+                    authRequiredForApi: false,
+                    email: signedIn ? 'member@example.com' : '',
+                    userId: signedIn ? 'user-member' : 'anonymous',
+                    workspaceId: 'workspace-local-active',
+                    betaAccess: true
+                });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/auth/logout')) {
+                signedIn = false;
+                return jsonResponse({ success: 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({
+                    ...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/tasks')) {
+                return jsonResponse({ tasks: mockTasks });
+            }
+            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/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/initiatives')) {
+                return jsonResponse([]);
+            }
+            if (url.includes('/api/taskforce/workstreams')) {
+                return jsonResponse([]);
+            }
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }));
+        await waitFor(() => {
+            expect(screen.getByTitle('Open tasks matching current filters')).toHaveTextContent('1/1');
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        await user.click(await screen.findByRole('menuitem', { name: 'Sign Out' }));
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('https://cloud.example.com/api/taskforce/auth/logout'))).toBe(true);
+            expect(screen.getByTitle('Open tasks matching current filters')).toHaveTextContent('1/1');
+        });
+        await user.click(screen.getByTitle(/Account/i));
+        expect(await screen.findByText('Sign In / Register')).toBeInTheDocument();
+    });
     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')) {
@@ -4745,13 +5431,14 @@ 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 () => {
+    it('opens edit profile from the account menu and saves the updated display name and avatar', async () => {
         const user = userEvent.setup();
         let savedDisplayName = 'Original Name';
+        let savedAvatarUrl = '';
         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' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/auth/session')) {
                 return jsonResponse({
@@ -4761,6 +5448,7 @@ describe('TaskforceCore Integration', () => {
                     userId: 'user-1',
                     email: 'user@example.com',
                     displayName: savedDisplayName,
+                    avatarUrl: savedAvatarUrl,
                     workspaceId: 'workspace-local-active'
                 });
             }
@@ -4817,15 +5505,38 @@ describe('TaskforceCore Integration', () => {
                 return jsonResponse({ templates: [] });
             if (url.includes('/api/taskforce/workspace/assignee-options'))
                 return jsonResponse({ options: [] });
+            if (url.includes('/api/taskforce/auth/profile/avatar/init')) {
+                return jsonResponse({
+                    success: true,
+                    draftId: 'avatar-draft-1',
+                    uploadUrl: 'https://upload.example.com/avatar-draft-1',
+                    relativePath: 'users/user-1/profile/avatar/avatar-draft-1-avatar.png',
+                    path: '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Favatar-draft-1-avatar.png'
+                });
+            }
+            if (url.includes('https://upload.example.com/avatar-draft-1')) {
+                return Promise.resolve({ ok: true, status: 200, json: async () => ({}) });
+            }
+            if (url.includes('/api/taskforce/auth/profile/avatar/finalize')) {
+                return jsonResponse({
+                    success: true,
+                    draftId: 'avatar-draft-1',
+                    avatarUrl: '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Favatar-draft-1-avatar.png'
+                });
+            }
             if (url.includes('/api/taskforce/auth/profile')) {
                 const body = JSON.parse(String(init?.body || '{}'));
                 savedDisplayName = String(body?.displayName || '').trim() || savedDisplayName;
+                if (body?.avatarDraftId === 'avatar-draft-1') {
+                    savedAvatarUrl = '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Favatar-draft-1-avatar.png';
+                }
                 return jsonResponse({
                     success: true,
                     profile: {
                         userId: 'user-1',
                         email: 'user@example.com',
-                        displayName: savedDisplayName
+                        displayName: savedDisplayName,
+                        avatarUrl: savedAvatarUrl
                     }
                 });
             }
@@ -4845,17 +5556,24 @@ describe('TaskforceCore Integration', () => {
         const displayNameInput = within(modal).getByPlaceholderText('Display name');
         await user.clear(displayNameInput);
         await user.type(displayNameInput, 'Updated Name');
+        const avatarInput = within(modal).getByLabelText('Upload profile photo');
+        await user.upload(avatarInput, new File(['avatar'], 'avatar.png', { type: 'image/png' }));
         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'));
+            const profileCall = fetchMock.mock.calls.find((call) => {
+                const url = String(call[0]);
+                return url.includes('/api/taskforce/auth/profile') && !url.includes('/api/taskforce/auth/profile/avatar/');
+            });
             expect(profileCall).toBeTruthy();
             const payload = JSON.parse(String(profileCall?.[1]?.body || '{}'));
             expect(payload.displayName).toBe('Updated Name');
+            expect(payload.avatarDraftId).toBe('avatar-draft-1');
         });
         await waitFor(() => {
             expect(screen.queryByText('Edit Profile')).not.toBeInTheDocument();
         });
         await user.click(screen.getByTitle(/Account/i));
         expect(await screen.findByText('Updated Name')).toBeInTheDocument();
+        expect(screen.getByTitle(/Account/i).querySelector('img')).toHaveAttribute('src', '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Favatar-draft-1-avatar.png');
     });
 });