@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/TaskforceCore.test.js

@@ -830,6 +830,9 @@ describe('TaskforceCore Integration', () => {
     });
     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/runtime-config')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } }) });
+            }
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
                     ok: true,
@@ -929,8 +932,8 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         plans: [
                             {
-                                planId: 'pro',
-                                displayName: 'Pro Plan test mode',
+                                planId: 'basic',
+                                displayName: 'Basic Plan test mode',
                                 status: 'active',
                                 features: [],
                                 pricing: { month: null, year: null },
@@ -946,7 +949,7 @@ describe('TaskforceCore Integration', () => {
         render(_jsx(MemoryRouter, { initialEntries: ['/pricing'], children: _jsx(TaskforceCore, {}) }));
         await waitFor(() => {
             expect(screen.queryByPlaceholderText('Email')).not.toBeInTheDocument();
-            expect(screen.getByText('Pro Plan test mode')).toBeInTheDocument();
+            expect(screen.getByText('Basic Plan test mode')).toBeInTheDocument();
             expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
         });
     });
@@ -1019,8 +1022,8 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         plans: [
                             {
-                                planId: 'starter',
-                                displayName: 'Starter',
+                                planId: 'free',
+                                displayName: 'Free',
                                 status: 'active',
                                 features: [],
                                 pricing: {
@@ -1028,7 +1031,7 @@ describe('TaskforceCore Integration', () => {
                                     year: null
                                 },
                                 defaultVersion: {
-                                    planVersionId: 'starter-v1',
+                                    planVersionId: 'free-v1',
                                     versionNumber: 1,
                                     seatLimit: null,
                                     metadata: {}
@@ -1042,8 +1045,8 @@ describe('TaskforceCore Integration', () => {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        planId: 'starter',
-                        planName: 'Starter',
+                        planId: 'free',
+                        planName: 'Free',
                         entitlementState: 'active'
                     })
                 });
@@ -1052,8 +1055,8 @@ describe('TaskforceCore Integration', () => {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        planId: 'starter',
-                        planName: 'Starter',
+                        planId: 'free',
+                        planName: 'Free',
                         entitlementState: 'active'
                     })
                 });
@@ -1154,8 +1157,8 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         plans: [
                             {
-                                planId: 'starter',
-                                displayName: 'Starter',
+                                planId: 'free',
+                                displayName: 'Free',
                                 status: 'active',
                                 features: [],
                                 pricing: {
@@ -1163,7 +1166,7 @@ describe('TaskforceCore Integration', () => {
                                     year: null
                                 },
                                 defaultVersion: {
-                                    planVersionId: 'starter-v1',
+                                    planVersionId: 'free-v1',
                                     versionNumber: 1,
                                     seatLimit: null,
                                     metadata: {}
@@ -1269,8 +1272,8 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         plans: [
                             {
-                                planId: 'starter',
-                                displayName: 'Starter',
+                                planId: 'free',
+                                displayName: 'Free',
                                 status: 'active',
                                 features: [],
                                 pricing: {
@@ -1278,7 +1281,7 @@ describe('TaskforceCore Integration', () => {
                                     year: null
                                 },
                                 defaultVersion: {
-                                    planVersionId: 'starter-v1',
+                                    planVersionId: 'free-v1',
                                     versionNumber: 1,
                                     seatLimit: null,
                                     metadata: {}
@@ -1292,9 +1295,9 @@ describe('TaskforceCore Integration', () => {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        planId: 'starter',
-                        planName: 'Starter',
-                        planVersionId: 'starter-v1',
+                        planId: 'free',
+                        planName: 'Free',
+                        planVersionId: 'free-v1',
                         entitlementState: 'active'
                     })
                 });
@@ -1323,7 +1326,7 @@ describe('TaskforceCore Integration', () => {
         render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&gate=missing_entitlement'], children: _jsx(TaskforceCore, {}) }));
         await waitFor(() => {
             expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-            expect(screen.getByText('Starter')).toBeInTheDocument();
+            expect(screen.getByText('Free')).toBeInTheDocument();
         });
         await waitFor(() => {
             expect(screen.queryByText('No entitlement is linked to this account.')).not.toBeInTheDocument();
@@ -1393,8 +1396,8 @@ describe('TaskforceCore Integration', () => {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        planId: 'starter',
-                        planName: 'Starter',
+                        planId: 'free',
+                        planName: 'Free',
                         entitlementState: 'active'
                     })
                 });
@@ -1450,14 +1453,14 @@ describe('TaskforceCore Integration', () => {
         });
         await waitFor(() => {
             expect(screen.getByText('Subscription')).toBeInTheDocument();
-            expect(screen.getByText('Starter')).toBeInTheDocument();
+            expect(screen.getByText('Free')).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('button', { name: /Subscription Starter/i }));
+        await user.click(screen.getByRole('button', { name: /Subscription Free/i }));
         await waitFor(() => {
             expect(screen.getByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
         });
@@ -1512,8 +1515,8 @@ describe('TaskforceCore Integration', () => {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        planId: 'starter',
-                        planName: 'Starter',
+                        planId: 'free',
+                        planName: 'Free',
                         entitlementState: 'active'
                     })
                 });
@@ -1563,7 +1566,7 @@ describe('TaskforceCore Integration', () => {
         }
         await waitFor(() => {
             expect(screen.getByText('Subscription')).toBeInTheDocument();
-            expect(screen.getByText('Starter')).toBeInTheDocument();
+            expect(screen.getByText('Free')).toBeInTheDocument();
             expect(screen.getByText('Runtime')).toBeInTheDocument();
             expect(screen.getByText('LOCAL')).toBeInTheDocument();
             expect(screen.getByText('Environment')).toBeInTheDocument();
@@ -1590,9 +1593,9 @@ describe('TaskforceCore Integration', () => {
                 userId: 'user-new',
                 displayName: 'New User',
                 workspaceId: 'workspace-local-active',
-                planId: 'starter',
-                planVersionId: 'starter-v1',
-                planName: 'Starter',
+                planId: 'free',
+                planVersionId: 'free-v1',
+                planName: 'Free',
                 teamManagementAllowed: false,
                 teamPlanMode: 'personal',
                 workspaceRole: 'member'
@@ -1690,11 +1693,11 @@ describe('TaskforceCore Integration', () => {
                 return jsonResponse({
                     plans: [
                         {
-                            planId: 'starter',
-                            displayName: 'Starter',
+                            planId: 'free',
+                            displayName: 'Free',
                             status: 'active',
                             defaultVersion: {
-                                planVersionId: 'starter-v1',
+                                planVersionId: 'free-v1',
                                 versionNumber: 1,
                                 seatLimit: null,
                                 metadata: {}
@@ -1825,7 +1828,7 @@ describe('TaskforceCore Integration', () => {
         await user.click(screen.getByTitle(/Account/i));
         await waitFor(() => {
             expect(screen.getByText(accounts.newcomer.email)).toBeInTheDocument();
-            expect(screen.getByText('Starter')).toBeInTheDocument();
+            expect(screen.getByText('Free')).toBeInTheDocument();
         });
         await user.click(screen.getByRole('menuitem', { name: 'Sign Out' }));
         await waitFor(() => {
@@ -1846,7 +1849,7 @@ describe('TaskforceCore Integration', () => {
         await waitFor(() => {
             expect(screen.getByText(accounts.ross.email)).toBeInTheDocument();
             expect(screen.getByText('Team 5')).toBeInTheDocument();
-            expect(screen.queryByText('Starter')).not.toBeInTheDocument();
+            expect(screen.queryByText('Free')).not.toBeInTheDocument();
             expect(screen.getByRole('menuitem', { name: 'Team Management' })).toBeInTheDocument();
         });
         await user.click(screen.getByRole('button', { name: /Subscription Team 5/i }));
@@ -1897,16 +1900,144 @@ describe('TaskforceCore Integration', () => {
         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.getByLabelText('Email')).toBeInTheDocument();
+            expect(screen.getByLabelText('Display name')).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(screen.getByTestId('auth-submit-button')).toBeInTheDocument();
+            expect(document.title).toBe('Create Account | Taskforce');
         });
         expect(container.querySelector('[aria-pressed]')).not.toBeInTheDocument();
     });
-    it('does not switch to verify mode after registration when verification is not required', async () => {
+    it('keeps the verification screen focused on verification and lets the user request a fresh email token', 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: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: false,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            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=verify'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Enter your verification token.')).toBeInTheDocument();
+            expect(screen.getByPlaceholderText('Email')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Verify Email' })).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Back to Sign In' })).toBeInTheDocument();
+            expect(screen.queryByRole('button', { name: 'Register' })).not.toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Resend Verification' })).toBeDisabled();
+        });
+    });
+    it('allows the verify screen to resend a verification email after the user re-enters their email', 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: 'cloud',
+                        authRequiredForApi: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: false,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            workspaceId: 'workspace-local-active',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/register')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        verificationRequired: true,
+                        workspaceSetupRequired: false,
+                        emailSent: true
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/verify-email/request')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        verificationToken: 'resent-token'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        plans: []
+                    })
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=verify'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'verify@example.com');
+        await user.click(screen.getByRole('button', { name: 'Resend Verification' }));
+        await waitFor(() => {
+            expect(screen.getByRole('button', { name: /Resend Verification/ })).toBeInTheDocument();
+            expect(screen.getByDisplayValue('resent-token')).toBeInTheDocument();
+            expect(screen.getByText('Verification email resent.')).toBeInTheDocument();
+        });
+        expect(screen.getByRole('button', { name: /Resend Verification/ })).toBeDisabled();
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/auth/verify-email/request'))).toBe(true);
+    });
+    it('shows neutral verification copy when resend succeeds without attempting delivery', async () => {
         const user = userEvent.setup();
         const fetchMock = vi.fn((input) => {
             const url = String(input);
@@ -1940,6 +2071,113 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
+            if (url.includes('/api/taskforce/auth/verify-email/request')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        emailSent: false,
+                        deliveryAttempted: false,
+                        verificationToken: null
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        plans: []
+                    })
+                });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=verify'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'verify@example.com');
+        await user.click(screen.getByRole('button', { name: 'Resend Verification' }));
+        await waitFor(() => {
+            expect(screen.getByText('If that account exists and still needs verification, we sent an email.')).toBeInTheDocument();
+        });
+    });
+    it('does not switch to verify mode after registration when verification is not required', 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 Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        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 Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        userId: authenticated ? 'user-no-verify' : null,
+                        workspaceId: null,
+                        betaAccess: true
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        workspaceSwitchingEnabled: true,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'missing',
+                            runtimeMode: 'cloud',
+                            workspaceId: 'default',
+                            mode: 'core',
+                            forceSetup: true,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: true
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspaces: [],
+                        currentWorkspaceId: 'default'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        gate: 'ok',
+                        hasEntitlement: true,
+                        canAccessApp: true,
+                        canAccessPlans: true,
+                        message: null
+                    })
+                });
+            }
             if (url.includes('/api/taskforce/public/pricing')) {
                 return Promise.resolve({
                     ok: true,
@@ -1949,12 +2187,14 @@ describe('TaskforceCore Integration', () => {
                 });
             }
             if (url.includes('/api/taskforce/auth/register')) {
+                authenticated = true;
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
                         success: true,
-                        workspaceSetupRequired: false,
-                        verificationRequired: false
+                        workspaceSetupRequired: true,
+                        verificationRequired: false,
+                        commercialState: 'active'
                     })
                 });
             }
@@ -1967,7 +2207,7 @@ describe('TaskforceCore Integration', () => {
         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.getByText('Configure your new workspace.')).toBeInTheDocument();
         });
         expect(screen.queryByPlaceholderText('Verification token')).not.toBeInTheDocument();
         expect(screen.queryByRole('button', { name: 'Create Account' })).not.toBeInTheDocument();
@@ -2054,11 +2294,11 @@ describe('TaskforceCore Integration', () => {
             if (url.includes('/api/taskforce/public/pricing')) {
                 return jsonResponse({
                     plans: [{
-                            planId: 'starter',
-                            displayName: 'Starter',
+                            planId: 'free',
+                            displayName: 'Free',
                             status: 'active',
                             defaultVersion: {
-                                planVersionId: 'starter-v1',
+                                planVersionId: 'free-v1',
                                 versionNumber: 1,
                                 seatLimit: null,
                                 metadata: {}
@@ -2066,10 +2306,10 @@ describe('TaskforceCore Integration', () => {
                             features: [],
                             pricing: {
                                 month: {
-                                    planVersionId: 'starter-v1',
+                                    planVersionId: 'free-v1',
                                     interval: 'month',
                                     pricingType: 'free',
-                                    stripePriceId: 'free:starter-v1:month',
+                                    stripePriceId: 'free:free-v1:month',
                                     displayAmount: '$0.00',
                                     unitAmount: 0,
                                     currency: 'usd'
@@ -2130,7 +2370,7 @@ describe('TaskforceCore Integration', () => {
         });
         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 () => {
+    it('keeps registration on plan selection when commercial onboarding is blocked even if the new cloud user has no workspace yet', async () => {
         const user = userEvent.setup();
         let authenticated = false;
         const fetchMock = vi.fn((input) => {
@@ -2154,8 +2394,8 @@ describe('TaskforceCore Integration', () => {
                     authenticated,
                     runtimeMode: 'cloud',
                     authRequiredForApi: true,
-                    userId: authenticated ? 'user-1' : null,
-                    workspaceId: authenticated ? 'workspace-1' : null,
+                    userId: authenticated ? 'user-new' : null,
+                    workspaceId: null,
                     betaAccess: true
                 });
             }
@@ -2167,9 +2407,9 @@ describe('TaskforceCore Integration', () => {
                     workspaceSwitchingEnabled: true,
                     setupState: {
                         globalSetupState: 'present',
-                        workspaceSetupState: 'present',
+                        workspaceSetupState: 'missing',
                         runtimeMode: 'cloud',
-                        workspaceId: 'workspace-1',
+                        workspaceId: 'default',
                         mode: 'core',
                         forceSetup: false,
                         forceGlobalSetup: false,
@@ -2180,67 +2420,183 @@ describe('TaskforceCore Integration', () => {
             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'
+                    workspaces: [],
+                    currentWorkspaceId: 'default'
                 });
             }
             if (url.includes('/api/taskforce/account/access-status')) {
                 return jsonResponse({
-                    gate: 'checkout_pending',
+                    gate: 'plan_selection_required',
                     hasEntitlement: true,
                     canAccessApp: false,
                     canAccessPlans: true,
-                    message: 'Complete checkout to continue.'
+                    message: 'Choose a plan to continue.'
                 });
             }
             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'
+                    entitlementState: 'pending_plan_selection',
+                    gate: 'plan_selection_required',
+                    message: 'Choose a plan to continue.',
+                    workspaceId: null
                 });
             }
             if (url.includes('/api/taskforce/public/pricing')) {
+                return jsonResponse({ plans: [] });
+            }
+            if (url.includes('/api/taskforce/auth/register')) {
+                authenticated = true;
                 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',
+                    success: true,
+                    workspaceSetupRequired: true,
+                    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'), 'brandnew@example.com');
+        await user.type(screen.getByPlaceholderText('Display name'), 'Brand New');
+        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(screen.queryByText('Configure your new workspace.')).not.toBeInTheDocument();
+    });
+    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'
+                });
+            }
+            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/account/profile-summary')) {
+                return jsonResponse({
+                    planId: 'basic',
+                    planName: 'Basic',
+                    planVersionId: 'basic-v1',
+                    entitlementState: 'checkout_pending',
+                    gate: 'checkout_pending',
+                    message: 'Complete checkout to continue.',
+                    workspaceId: 'workspace-1'
+                });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return jsonResponse({
+                    plans: [{
+                            planId: 'basic',
+                            displayName: 'Basic',
+                            status: 'active',
+                            defaultVersion: {
+                                planVersionId: 'basic-v1',
+                                versionNumber: 1,
+                                seatLimit: null,
+                                metadata: {}
+                            },
+                            features: [],
+                            pricing: {
+                                month: {
+                                    planVersionId: 'basic-v1',
+                                    interval: 'month',
+                                    pricingType: 'stripe',
+                                    stripePriceId: 'price_basic_month',
+                                    displayAmount: '$19.00',
+                                    unitAmount: 1900,
+                                    currency: 'usd'
+                                },
+                                year: {
+                                    planVersionId: 'basic-v1',
+                                    interval: 'year',
+                                    pricingType: 'stripe',
+                                    stripePriceId: 'price_basic_year',
+                                    displayAmount: '$190.00',
                                     unitAmount: 19000,
                                     currency: 'usd'
                                 }
@@ -2294,7 +2650,7 @@ describe('TaskforceCore Integration', () => {
             return jsonResponse({});
         });
         vi.stubGlobal('fetch', fetchMock);
-        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&planId=pro&planVersionId=pro-v1&interval=year&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&planId=basic&planVersionId=basic-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!');
@@ -2306,69 +2662,330 @@ describe('TaskforceCore Integration', () => {
             expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/billing/checkout-session'))).toBe(true);
         });
     });
-    it('shows verification before workspace setup when registration still requires email verification', async () => {
+    it('routes successful registration into workspace setup when onboarding auto-grants free, even if a stale pre-registration session check resolves later', async () => {
         const user = userEvent.setup();
+        let authenticated = false;
+        let authSessionCallCount = 0;
+        let releaseInitialSession = null;
+        const initialSessionGate = new Promise((resolve) => {
+            releaseInitialSession = resolve;
+        });
         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,
+            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')) {
+                authSessionCallCount += 1;
+                const payload = () => ({
+                    authenticated,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: authenticated ? 'user-free-1' : null,
+                    workspaceId: null,
+                    betaAccess: true
                 });
+                if (authSessionCallCount === 1) {
+                    return initialSessionGate.then(() => jsonResponse(payload()));
+                }
+                return jsonResponse(payload());
             }
             if (url.includes('/api/taskforce/config')) {
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        ...mockConfig,
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    workspaceSwitchingEnabled: true,
+                    setupState: {
+                        globalSetupState: 'present',
+                        workspaceSetupState: 'missing',
                         runtimeMode: 'cloud',
-                        authRequiredForApi: true,
-                        setupState: {
-                            globalSetupState: 'present',
-                            workspaceSetupState: 'present',
-                            runtimeMode: 'cloud',
-                            workspaceId: 'default',
-                            mode: 'core',
-                            forceSetup: false,
-                            forceGlobalSetup: false,
-                            forceWorkspaceSetup: false
-                        }
-                    })
+                        workspaceId: 'default',
+                        mode: 'core',
+                        forceSetup: true,
+                        forceGlobalSetup: false,
+                        forceWorkspaceSetup: true
+                    }
                 });
             }
-            if (url.includes('/api/taskforce/public/pricing')) {
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        plans: []
-                    })
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    workspaces: [],
+                    currentWorkspaceId: 'default'
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return jsonResponse({
+                    gate: 'ok',
+                    hasEntitlement: true,
+                    canAccessApp: true,
+                    canAccessPlans: true,
+                    message: null
                 });
             }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return jsonResponse({ plans: [] });
+            }
             if (url.includes('/api/taskforce/auth/register')) {
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        success: true,
-                        workspaceSetupRequired: true,
-                        verificationRequired: true,
-                        emailSent: true
-                    })
+                authenticated = true;
+                return jsonResponse({
+                    success: true,
+                    workspaceSetupRequired: true,
+                    verificationRequired: false,
+                    commercialState: 'active'
                 });
             }
-            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+            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: [] });
+            if (url.includes('/api/taskforce/taxonomy-library')) {
+                return jsonResponse({
+                    packs: [{
+                            id: 'general',
+                            label: 'General',
+                            description: 'Starter',
+                            isDefaultStarter: true,
+                            sections: {
+                                categories: [{ value: 'general', label: 'General' }],
+                                taskTypes: [{ value: 'task', label: 'Task' }],
+                                priorities: [{ value: 1, label: 'Low' }]
+                            }
+                        }]
+                });
+            }
+            return jsonResponse({});
         });
         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');
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=register&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'free-user@example.com');
+        await user.type(screen.getByPlaceholderText('Display name'), 'Free User');
         await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
         await user.click(screen.getByRole('button', { name: 'Create Account' }));
+        await act(async () => {
+            await Promise.resolve();
+        });
         await waitFor(() => {
-            expect(screen.getByPlaceholderText('Verification token')).toBeInTheDocument();
+            expect(screen.getByText('Configure your new workspace.')).toBeInTheDocument();
+        });
+        expect(fetchMock.mock.calls.filter(([url]) => String(url).includes('/api/taskforce/auth/session')).length).toBeGreaterThanOrEqual(2);
+        await act(async () => {
+            releaseInitialSession?.();
+            await Promise.resolve();
+        });
+        await waitFor(() => {
+            expect(screen.getByText('Configure your new workspace.')).toBeInTheDocument();
+        });
+        expect(screen.queryByText('Sign in with your account credentials.')).not.toBeInTheDocument();
+    });
+    it('routes successful registration directly into the app when onboarding auto-grants free and the new cloud user already has an accessible workspace', 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-free-2' : null,
+                    workspaceId: authenticated ? 'workspace-1' : null,
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    workspaceSwitchingEnabled: true,
+                    workspaceId: 'workspace-1',
+                    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: 'ok',
+                    hasEntitlement: true,
+                    canAccessApp: true,
+                    canAccessPlans: true,
+                    message: null
+                });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return jsonResponse({ plans: [] });
+            }
+            if (url.includes('/api/taskforce/auth/register')) {
+                authenticated = true;
+                return jsonResponse({
+                    success: true,
+                    workspaceSetupRequired: false,
+                    verificationRequired: false,
+                    commercialState: 'active'
+                });
+            }
+            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'), 'existing-workspace@example.com');
+        await user.type(screen.getByPlaceholderText('Display name'), 'Existing Workspace User');
+        await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
+        await user.click(screen.getByRole('button', { name: 'Create Account' }));
+        await act(async () => {
+            await Promise.resolve();
+        });
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        expect(screen.queryByText('Configure your new workspace.')).not.toBeInTheDocument();
+        expect(screen.queryByRole('heading', { name: 'Subscription Plans' })).not.toBeInTheDocument();
+    });
+    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);
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: false,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            workspaceId: 'default',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: false
+                        }
+                    })
+                });
+            }
+            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: true,
+                        verificationRequired: true,
+                        emailSent: true
+                    })
+                });
+            }
+            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('Verification token')).toBeInTheDocument();
         });
         expect(screen.queryByRole('button', { name: 'Create Account' })).not.toBeInTheDocument();
         expect(screen.queryByText('Subscription Plans')).not.toBeInTheDocument();
@@ -2426,7 +3043,7 @@ describe('TaskforceCore Integration', () => {
             expect(screen.getByRole('button', { name: 'Register' })).toBeInTheDocument();
         });
     });
-    it('redirects register users to plans when signup plan configuration blocks account creation', async () => {
+    it('shows neutral password reset copy when reset delivery was not attempted', async () => {
         const user = userEvent.setup();
         const fetchMock = vi.fn((input) => {
             const url = String(input);
@@ -2454,7 +3071,7 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         authenticated: false,
                         runtimeMode: 'cloud',
-                        authRequiredForApi: true
+                        authRequiredForApi: false
                     })
                 });
             }
@@ -2464,7 +3081,7 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         ...mockConfig,
                         runtimeMode: 'cloud',
-                        authRequiredForApi: true,
+                        authRequiredForApi: false,
                         setupState: {
                             globalSetupState: 'present',
                             workspaceSetupState: 'present',
@@ -2478,62 +3095,59 @@ 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')) {
+            if (url.includes('/api/taskforce/auth/password-reset/request')) {
                 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' }
-                                }
-                            }
-                        ]
+                        success: true,
+                        emailSent: false,
+                        deliveryAttempted: false,
+                        resetToken: null
                     })
                 });
             }
-            if (url.includes('/api/taskforce/auth/register')) {
-                return Promise.resolve({
-                    ok: false,
-                    json: () => Promise.resolve({
-                        success: false,
-                        code: 'SIGNUP_PLAN_NOT_ENABLED',
-                        error: 'Configured onboarding plan version \"team-10-v1\" belongs to a disabled plan.'
-                    })
-                });
+            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=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' }));
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=forgot&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'nobody@example.com');
+        await user.click(screen.getByRole('button', { name: 'Send Reset Link' }));
         await waitFor(() => {
-            expect(screen.getByText('Choose a plan to continue.')).toBeInTheDocument();
-            expect(screen.getByText('Subscription Plans')).toBeInTheDocument();
+            expect(screen.getByText('If that account exists, we sent password reset instructions.')).toBeInTheDocument();
         });
     });
-    it('shows sign-in continuation for existing-user invites', async () => {
-        const fetchMock = vi.fn((url) => {
+    it('keeps forgot-password users on the request form when reset delivery fails', 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: 'https://app.taskforce.example',
+                            apiBaseUrl: 'https://app.taskforce.example/api',
+                            cloudAuthBaseUrl: 'https://app.taskforce.example',
+                            runtimeMode: 'cloud',
+                            authSource: 'cloud',
+                            workspaceMode: 'multi-cloud',
+                            workspaceSwitchingEnabled: true,
+                            cloudAuthViaLocalProxy: false
+                        }
+                    })
+                });
+            }
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
                         authenticated: false,
                         runtimeMode: 'cloud',
-                        authRequiredForApi: true
+                        authRequiredForApi: false
                     })
                 });
             }
@@ -2543,12 +3157,12 @@ describe('TaskforceCore Integration', () => {
                     json: () => Promise.resolve({
                         ...mockConfig,
                         runtimeMode: 'cloud',
-                        authRequiredForApi: true,
+                        authRequiredForApi: false,
                         setupState: {
                             globalSetupState: 'present',
                             workspaceSetupState: 'present',
                             runtimeMode: 'cloud',
-                            workspaceId: 'workspace-1',
+                            workspaceId: 'workspace-local-active',
                             mode: 'core',
                             forceSetup: false,
                             forceGlobalSetup: false,
@@ -2557,16 +3171,15 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            if (url.includes('/api/taskforce/auth/invite/inspect')) {
+            if (url.includes('/api/taskforce/auth/password-reset/request')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
                         success: true,
-                        state: 'valid',
-                        email: 'existing@example.com',
-                        workspaceId: 'workspace-1',
-                        inviteeKind: 'existing_user',
-                        passwordRequired: false
+                        emailSent: false,
+                        deliveryAttempted: true,
+                        emailError: 'SMTP temporary failure',
+                        resetToken: null
                     })
                 });
             }
@@ -2576,16 +3189,38 @@ describe('TaskforceCore Integration', () => {
             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, {}) }));
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=forgot&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'owner@example.com');
+        await user.click(screen.getByRole('button', { name: 'Send Reset Link' }));
         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();
+            expect(screen.getByText('Password reset email failed to send. SMTP temporary failure')).toBeInTheDocument();
         });
+        expect(screen.getByText('Request a password reset link.')).toBeInTheDocument();
+        expect(screen.queryByText('Enter the password reset token and choose a new password.')).not.toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Send Reset Link' })).toBeInTheDocument();
     });
-    it('shows password creation for new-user invites', async () => {
-        const fetchMock = vi.fn((url) => {
+    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: 'https://app.taskforce.example',
+                            apiBaseUrl: 'https://app.taskforce.example/api',
+                            cloudAuthBaseUrl: 'https://app.taskforce.example',
+                            runtimeMode: 'cloud',
+                            authSource: 'cloud',
+                            workspaceMode: 'multi-cloud',
+                            workspaceSwitchingEnabled: true,
+                            cloudAuthViaLocalProxy: false
+                        }
+                    })
+                });
+            }
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
                     ok: true,
@@ -2607,7 +3242,7 @@ describe('TaskforceCore Integration', () => {
                             globalSetupState: 'present',
                             workspaceSetupState: 'present',
                             runtimeMode: 'cloud',
-                            workspaceId: 'workspace-1',
+                            workspaceId: 'workspace-local-active',
                             mode: 'core',
                             forceSetup: false,
                             forceGlobalSetup: false,
@@ -2616,80 +3251,97 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            if (url.includes('/api/taskforce/auth/invite/inspect')) {
+            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({
-                        success: true,
-                        state: 'valid',
-                        email: 'new@example.com',
-                        workspaceId: 'workspace-1',
-                        inviteeKind: 'new_user',
-                        passwordRequired: true
+                        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/workflow-templates')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+            if (url.includes('/api/taskforce/auth/register')) {
+                return Promise.resolve({
+                    ok: false,
+                    json: () => Promise.resolve({
+                        success: false,
+                        code: 'SIGNUP_PLAN_NOT_ENABLED',
+                        error: 'Configured onboarding 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=invite&token=invite-token&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        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('Create your account to join this workspace.')).toBeInTheDocument();
-            expect(screen.getByPlaceholderText('Create password')).toBeInTheDocument();
-            expect(screen.getByRole('button', { name: 'Create Account and Join' })).toBeInTheDocument();
+            expect(screen.getByText('Choose a plan to continue.')).toBeInTheDocument();
+            expect(screen.getByText('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('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: true,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false
+                        authenticated: 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,
                         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/tasks')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            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: [] }) });
@@ -2697,28 +3349,28 @@ describe('TaskforceCore Integration', () => {
             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' }));
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=invite&token=invite-token&next=%2F'], children: _jsx(TaskforceCore, {}) }));
         await waitFor(() => {
-            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+            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();
         });
-        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) => {
+    it('uses invite join after invite-mode sign-in even if invite reinspection has not refreshed yet', async () => {
+        let authenticated = false;
+        let inviteInspectCalls = 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
+                        authenticated,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        userId: authenticated ? 'user-existing' : 'anonymous',
+                        workspaceId: authenticated ? 'workspace-home' : 'default',
+                        email: authenticated ? 'existing@example.com' : null
                     })
                 });
             }
@@ -2727,37 +3379,92 @@ describe('TaskforceCore Integration', () => {
                     ok: true,
                     json: () => Promise.resolve({
                         ...mockConfig,
-                        runtimeMode: 'local',
-                        authRequiredForApi: false,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
                         setupState: {
                             globalSetupState: 'present',
-                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
-                            runtimeMode: 'local',
-                            workspaceId: 'default',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            workspaceId: authenticated ? 'workspace-home' : '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
+                            forceWorkspaceSetup: false
                         }
                     })
                 });
             }
-            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/auth/invite/inspect')) {
+                inviteInspectCalls += 1;
+                if (authenticated && inviteInspectCalls > 1) {
+                    return new Promise(() => undefined);
+                }
+                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/auth/login')) {
+                authenticated = true;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({ success: true })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/invite/join')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({ success: true, workspaceId: 'workspace-1' })
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        currentWorkspaceId: authenticated ? 'workspace-home' : null,
+                        workspaces: authenticated
+                            ? [{ id: 'workspace-home', name: 'Home workspace', role: 'owner' }]
+                            : []
+                    })
+                });
             }
             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: [], config: {} }) });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        authenticated,
+                        commercialState: 'active',
+                        planSelectionRequired: false,
+                        checkoutPending: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        currentWorkspaceId: authenticated ? 'workspace-home' : null,
+                        workspaces: authenticated ? [{ id: 'workspace-home', name: 'Home workspace' }] : []
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, workspaceId: 'workspace-1' }) });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: null }) });
             }
             if (url.includes('/api/taskforce/workflow-templates')) {
                 return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
@@ -2765,160 +3472,1132 @@ describe('TaskforceCore Integration', () => {
             return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
         });
         vi.stubGlobal('fetch', fetchMock);
-        render(_jsx(MemoryRouter, { initialEntries: ['/'], children: _jsx(TaskforceCore, {}) }));
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=invite&token=invite-token&next=%2F'], children: _jsx(TaskforceCore, {}) }));
         await waitFor(() => {
-            expect(screen.getByText('Workspace Setup Required')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Sign In to Continue' })).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 userEvent.type(screen.getByPlaceholderText('Password'), 'ExistingUserPass123!');
+        await userEvent.click(screen.getByTestId('auth-submit-button'));
         await waitFor(() => {
-            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+            expect(screen.getByText('Signed in. Review the invite details to continue.')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Join Workspace' })).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';
+        await userEvent.click(screen.getByTestId('auth-submit-button'));
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/auth/invite/join'))).toBe(true);
         });
-        const workspaceSyncStateBody = JSON.parse(String(workspaceSyncStateCall?.[1]?.body || '{}'));
-        expect(workspaceSyncStateBody.stateKey).toBe('workspace-sync');
-        expect(workspaceSyncStateBody.patch?.enabled).toBe(false);
+        expect(fetchMock.mock.calls.filter((call) => String(call[0]).includes('/api/taskforce/auth/login'))).toHaveLength(1);
     });
-    it('applies the selected starter taxonomy pack during workspace setup', async () => {
-        const user = userEvent.setup();
-        let workspaceSaved = false;
+    it('keeps existing-user invites recoverable when the wrong account signs in first', async () => {
+        let authenticated = false;
+        let sessionEmail = null;
         const fetchMock = vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/session')) {
-                return jsonResponse({
-                    authenticated: true,
-                    runtimeMode: 'local',
-                    authRequiredForApi: false
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        userId: authenticated ? 'user-other' : 'anonymous',
+                        workspaceId: authenticated ? 'workspace-home' : 'default',
+                        email: sessionEmail
+                    })
                 });
             }
             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: {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        ...mockConfig,
+                        runtimeMode: 'cloud',
+                        authRequiredForApi: true,
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'present',
+                            runtimeMode: 'cloud',
+                            workspaceId: authenticated ? 'workspace-home' : 'default',
+                            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/auth/login')) {
+                const body = typeof init?.body === 'string' ? JSON.parse(init.body) : {};
+                authenticated = true;
+                sessionEmail = String(body?.email || '').trim().toLowerCase() || null;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({ success: true })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/invite/join')) {
+                return Promise.resolve({
+                    ok: false,
+                    json: () => Promise.resolve({
+                        success: false,
+                        code: 'INVITE_ACCOUNT_MISMATCH',
+                        error: 'Sign in with the invited account to join this workspace.'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        currentWorkspaceId: authenticated ? 'workspace-home' : null,
+                        workspaces: authenticated
+                            ? [{ id: 'workspace-home', name: 'Home workspace', role: 'owner' }]
+                            : []
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [], config: {} }) });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        authenticated,
+                        commercialState: 'active',
+                        planSelectionRequired: false,
+                        checkoutPending: false
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        currentWorkspaceId: authenticated ? 'workspace-home' : null,
+                        workspaces: authenticated ? [{ id: 'workspace-home', name: 'Home workspace' }] : []
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, workspaceId: 'workspace-home' }) });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: null }) });
+            }
+            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.getByRole('button', { name: 'Sign In to Continue' })).toBeInTheDocument();
+        });
+        await userEvent.clear(screen.getByPlaceholderText('Email'));
+        await userEvent.type(screen.getByPlaceholderText('Email'), 'other@example.com');
+        await userEvent.type(screen.getByPlaceholderText('Password'), 'OtherUserPass123!');
+        await userEvent.click(screen.getByTestId('auth-submit-button'));
+        await waitFor(() => {
+            expect(screen.getByText('Sign in with the invited account to join this workspace.')).toBeInTheDocument();
+            expect(screen.getByDisplayValue('existing@example.com')).toBeInTheDocument();
+            expect(screen.getByPlaceholderText('Password')).toBeInTheDocument();
+            expect(screen.queryByRole('button', { name: 'Join Workspace' })).not.toBeInTheDocument();
+        });
+        expect(fetchMock.mock.calls.filter((call) => String(call[0]).includes('/api/taskforce/auth/login'))).toHaveLength(1);
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/auth/invite/join'))).toBe(false);
+    });
+    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',
-                        supportsCloudAuth: false,
-                        supportsAdminManagedSetupOverrides: false,
-                        supportsPackageScriptSetupOverrides: true
-                    }
+                        authRequiredForApi: false
+                    })
                 });
             }
-            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' }]
+            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
                         },
-                        {
-                            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' }
-                            ]
+                        runtimeCapabilities: {
+                            runtimeMode: 'local',
+                            supportsCloudAuth: false,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: true
                         }
-                    ]
+                    })
                 });
             }
-            if (url.includes('/api/taskforce/workspace-profile')) {
+            if (url.includes('/api/taskforce/global-settings')) {
                 const body = JSON.parse(String(init?.body || '{}'));
-                if (body?.name === 'Starter Workspace')
-                    workspaceSaved = true;
-                return jsonResponse({
-                    success: true,
-                    workspace: {
-                        id: 'workspace-starter-1'
-                    }
+                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('Configure your new workspace.')).toBeInTheDocument();
+        });
+        const nameInput = screen.getByPlaceholderText('Workspace name');
+        await user.clear(nameInput);
+        await user.type(nameInput, 'Delta Project');
+        await user.type(screen.getByPlaceholderText('Workspace description (optional)'), 'Workspace desc');
+        await user.click(screen.getByRole('button', { name: 'Continue' }));
+        await user.click(screen.getByRole('button', { name: 'Create Workspace' }));
+        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('creates the first cloud workspace through the workspace creation flow during setup', async () => {
+        const user = userEvent.setup();
+        let workspaceCreated = false;
+        const fetchMock = vi.fn((input, init) => {
+            const url = String(input);
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    success: true,
+                    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,
+                        cloudAuthViaLocalProxy: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-cloud-1',
+                    workspaceId: workspaceCreated ? 'workspace-cloud-new' : 'default'
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return jsonResponse({
+                    gate: 'ok',
+                    hasEntitlement: true,
+                    canAccessApp: true,
+                    canAccessPlans: true,
+                    message: null
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-cloud-1',
+                    projectName: workspaceCreated ? 'Cloud Mission' : '',
+                    setupState: {
+                        globalSetupState: 'present',
+                        workspaceSetupState: workspaceCreated ? 'present' : 'missing',
+                        runtimeMode: 'cloud',
+                        workspaceId: workspaceCreated ? 'workspace-cloud-new' : 'default',
+                        mode: 'core',
+                        forceSetup: false,
+                        forceGlobalSetup: false,
+                        forceWorkspaceSetup: false,
+                        workspace: workspaceCreated
+                            ? { id: 'workspace-cloud-new', slug: 'workspace-cloud-new', name: 'Cloud Mission', description: 'Cloud workspace desc' }
+                            : null,
+                        suggestedWorkspaceName: ''
+                    },
+                    runtimeCapabilities: {
+                        runtimeMode: 'cloud',
+                        supportsCloudAuth: true,
+                        supportsAdminManagedSetupOverrides: true,
+                        supportsPackageScriptSetupOverrides: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces') && String(init?.method || 'GET').toUpperCase() === 'GET') {
+                return jsonResponse({
+                    success: true,
+                    workspaces: workspaceCreated
+                        ? [{
+                                id: 'workspace-cloud-new',
+                                slug: 'workspace-cloud-new',
+                                name: 'Cloud Mission',
+                                description: 'Cloud workspace desc',
+                                role: 'owner',
+                                status: 'active',
+                                betaAccess: true
+                            }]
+                        : [],
+                    currentWorkspaceId: workspaceCreated ? 'workspace-cloud-new' : 'default'
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces') && String(init?.method || '').toUpperCase() === 'POST') {
+                workspaceCreated = true;
+                return jsonResponse({
+                    success: true,
+                    workspace: {
+                        id: 'workspace-cloud-new',
+                        slug: 'workspace-cloud-new',
+                        name: 'Cloud Mission',
+                        description: 'Cloud workspace desc',
+                        role: 'owner',
+                        status: 'active',
+                        betaAccess: true
+                    }
+                }, 201);
+            }
+            if (url.includes('/api/taskforce/session/workspace')) {
+                return jsonResponse({
+                    success: true,
+                    workspaceId: 'workspace-cloud-new',
+                    role: 'owner'
+                });
+            }
+            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/ui-state')) {
+                return jsonResponse({ success: true });
+            }
+            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: ['/setup?step=workspace'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByText('Configure your new workspace.')).toBeInTheDocument();
+        });
+        expect(screen.getByLabelText('Cloud runtime')).toBeInTheDocument();
+        const nameInput = screen.getByPlaceholderText('Workspace name');
+        await user.clear(nameInput);
+        await user.type(nameInput, 'Cloud Mission');
+        await user.type(screen.getByPlaceholderText('Workspace description (optional)'), 'Cloud workspace desc');
+        await user.click(screen.getByRole('button', { name: 'Continue' }));
+        await user.click(screen.getByRole('button', { name: 'Create Workspace' }));
+        await waitFor(() => {
+            expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
+        });
+        expect(fetchMock.mock.calls.some((call) => (String(call[0]).includes('/api/taskforce/workspaces')
+            && String(call[1]?.method || '').toUpperCase() === 'POST'))).toBe(true);
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/workspace-profile'))).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('Configure your new workspace.')).toBeInTheDocument();
+        });
+        expect(screen.getByLabelText('Local runtime')).toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: 'Continue' }));
+        expect(screen.queryByRole('radio', { name: /create new local workspace/i })).not.toBeInTheDocument();
+        expect(screen.queryByRole('radio', { name: /sync existing cloud workspace/i })).not.toBeInTheDocument();
+        expect(screen.queryByText(/Includes \d+ categories?/i)).not.toBeInTheDocument();
+        expect(screen.getByRole('option', { name: 'General' })).toBeInTheDocument();
+        expect(screen.getByText('Task')).toBeInTheDocument();
+        expect(screen.getByText('Low')).toBeInTheDocument();
+        await user.selectOptions(screen.getByRole('combobox'), 'software-development');
+        expect(screen.getByText('Engineering')).toBeInTheDocument();
+        expect(screen.getByText('Feature, Bug')).toBeInTheDocument();
+        expect(screen.getByText('Low, Medium, High, Critical')).toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: 'Continue' }));
+        await user.click(screen.getByRole('button', { name: 'Create Workspace' }));
+        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('Configure your new workspace.')).not.toBeInTheDocument();
+    });
+    it('keeps setup blocking while the selected cloud workspace is performing its first local import', 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?key=workspace-sync')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        state: workspaceSaved
+                            ? {
+                                version: 2,
+                                enabled: true,
+                                phase: 'attach-cloud',
+                                pullCursor: null,
+                                lastPullAt: null,
+                                lastPushAt: null,
+                                lastSyncedAt: null
+                            }
+                            : {
+                                version: 2,
+                                enabled: false,
+                                phase: 'idle',
+                                pullCursor: null,
+                                lastPullAt: null,
+                                lastPushAt: null,
+                                lastSyncedAt: null
+                            }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/handshake')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('https://cloud.example.com/api/taskforce/sync/workspace/pull')) {
+                return new Promise(() => { });
+            }
+            if (url === '/api/taskforce/sync/workspace/apply-local') {
+                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('Configure your new workspace.')).toBeInTheDocument();
+        });
+        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: 'Connect Workspace' }));
+        await waitFor(() => {
+            expect(screen.getByText('Importing "Cloud Project 123" from cloud into local.')).toBeInTheDocument();
+        });
+        expect(screen.getByText('Configure your new workspace.')).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Importing Workspace...' })).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?.enabled).toBe(true);
+        expect(workspaceSyncStateBody.patch?.phase).toBe('attach-cloud');
+        expect(workspaceSyncStateBody.patch?.setupIntent).toBe('attach-cloud-import');
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('https://cloud.example.com/api/taskforce/workspaces'))).toBe(true);
+        expect(screen.queryByTitle(/Account/i)).not.toBeInTheDocument();
+    });
+    it('keeps attach-cloud import blocking after refresh when setup intent is persisted', async () => {
+        const fetchMock = 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: 'cloud' } }) });
+            }
+            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-cloud-123',
+                        setupState: {
+                            globalSetupState: 'present',
+                            workspaceSetupState: 'missing',
+                            runtimeMode: 'local',
+                            workspaceId: 'workspace-cloud-123',
+                            mode: 'core',
+                            forceSetup: false,
+                            forceGlobalSetup: false,
+                            forceWorkspaceSetup: true,
+                            workspace: null,
+                            suggestedWorkspaceName: 'Cloud Project 123'
+                        },
+                        runtimeCapabilities: {
+                            runtimeMode: 'local',
+                            supportsCloudAuth: true,
+                            supportsAdminManagedSetupOverrides: false,
+                            supportsPackageScriptSetupOverrides: true
+                        }
+                    })
+                });
+            }
+            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: 'attach-cloud',
+                            setupIntent: 'attach-cloud-import',
+                            pullCursor: null,
+                            lastPullAt: null,
+                            lastPushAt: null,
+                            lastSyncedAt: null
+                        }
+                    })
+                });
+            }
+            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/ui-state?key=app')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: {} }) });
+            }
+            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/categories')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
+            }
+            if (url.includes('/api/taskforce/global-settings')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+            }
+            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: [] }) });
+            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, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        await waitFor(() => {
+            expect(screen.getByText('Configure your new workspace.')).toBeInTheDocument();
+        });
+        await waitFor(() => {
+            expect(screen.getByText('Importing "Cloud Project 123" from cloud into local.')).toBeInTheDocument();
+        });
+    });
+    it('clears persisted attach-cloud import intent after the first successful import', async () => {
+        const uiStatePosts = [];
+        const fetchMock = vi.fn((url, init) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } }) });
+            }
+            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-cloud-123'
+                    })
+                });
+            }
+            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',
+                            setupIntent: 'attach-cloud-import',
+                            pullCursor: 'cursor-1',
+                            lastPullAt: '2026-04-15T12:00:00.000Z',
+                            lastPushAt: null,
+                            lastSyncedAt: '2026-04-15T12:00:00.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('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/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/ui-state?key=app')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true, state: {} }) });
             }
             if (url.includes('/api/taskforce/tasks')) {
-                return jsonResponse({ tasks: mockTasks });
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
             }
             if (url.includes('/api/taskforce/archive')) {
-                return jsonResponse({ archived: [] });
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
             }
-            if (url.includes('/api/taskforce/workflow-templates')) {
-                return jsonResponse({ templates: [] });
+            if (url.includes('/api/taskforce/categories')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve(mockCategories) });
             }
-            return jsonResponse({});
+            if (url.includes('/api/taskforce/global-settings')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+            }
+            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: [] }) });
+            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, {}) }));
+        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();
+            expect(screen.getByText('Test Project')).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();
+            expect(uiStatePosts.some((entry) => entry?.stateKey === 'workspace-sync' && entry?.patch?.setupIntent === null)).toBe(true);
         });
-        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;
+    it('shows sign-in and register actions on signed-out cloud workspace setup and disables connect', async () => {
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
@@ -2931,29 +4610,23 @@ describe('TaskforceCore Integration', () => {
                 });
             }
             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',
+                            workspaceSetupState: 'missing',
                             runtimeMode: 'local',
-                            workspaceId: 'workspace-local-refresh',
+                            workspaceId: 'default',
                             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'
+                            forceWorkspaceSetup: true,
+                            workspace: null,
+                            suggestedWorkspaceName: 'Suggested Project'
                         },
                         runtimeCapabilities: {
                             runtimeMode: 'local',
@@ -2964,46 +4637,26 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            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, {}) }));
+        render(_jsx(MemoryRouter, { initialEntries: ['/setup?step=workspace&source=cloud&postAuth=select-cloud-workspace'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
         await waitFor(() => {
-            expect(configCalls).toBeGreaterThan(1);
+            expect(screen.getByText('Configure your new workspace.')).toBeInTheDocument();
         });
-        expect(screen.getByRole('button', { name: /add task/i })).toBeInTheDocument();
-        expect(screen.queryByText('Workspace Setup Required')).not.toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Sign In' })).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Register' })).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Connect Workspace' })).toBeDisabled();
     });
-    it('allows workspace setup to sync from selected cloud project into matching local workspace id', async () => {
+    it('returns signed-in users to the cloud workspace picker after setup sign-in', async () => {
         const user = userEvent.setup();
-        let workspaceSaved = false;
+        let authenticated = false;
         const fetchMock = vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/session')) {
                 return Promise.resolve({
                     ok: true,
                     json: () => Promise.resolve({
-                        authenticated: true,
+                        authenticated,
                         runtimeMode: 'local',
                         authRequiredForApi: false
                     })
@@ -3018,16 +4671,14 @@ describe('TaskforceCore Integration', () => {
                         authRequiredForApi: false,
                         setupState: {
                             globalSetupState: 'present',
-                            workspaceSetupState: workspaceSaved ? 'present' : 'missing',
+                            workspaceSetupState: 'missing',
                             runtimeMode: 'local',
-                            workspaceId: workspaceSaved ? 'workspace-cloud-123' : 'default',
+                            workspaceId: '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,
+                            workspace: null,
                             suggestedWorkspaceName: 'Suggested Project'
                         },
                         runtimeCapabilities: {
@@ -3039,6 +4690,16 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
+            if (url.includes('/api/taskforce/auth/login') && String(init?.method || '').toUpperCase() === 'POST') {
+                authenticated = true;
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        success: true,
+                        workspaceSetupRequired: true
+                    })
+                });
+            }
             if (url.includes('https://cloud.example.com/api/taskforce/workspaces')) {
                 return Promise.resolve({
                     ok: true,
@@ -3054,64 +4715,135 @@ describe('TaskforceCore Integration', () => {
                     })
                 });
             }
-            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'
-                        }
-                    })
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/setup?step=workspace&source=cloud&postAuth=select-cloud-workspace'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        await waitFor(() => {
+            expect(screen.getByRole('button', { name: 'Sign In' })).toBeInTheDocument();
+        });
+        await user.click(screen.getByRole('button', { name: 'Sign In' }));
+        await waitFor(() => {
+            expect(screen.getByTestId('auth-email-input')).toBeInTheDocument();
+        });
+        await user.type(screen.getByTestId('auth-email-input'), 'agent@example.com');
+        await user.type(screen.getByTestId('auth-password-input'), 'password123');
+        await user.click(screen.getByTestId('auth-submit-button'));
+        await waitFor(() => {
+            expect(screen.getByRole('option', { name: /Cloud Project 123/ })).toBeInTheDocument();
+        });
+        await waitFor(() => {
+            expect(screen.queryByRole('button', { name: 'Register' })).not.toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Connect Workspace' })).toBeEnabled();
+        });
+    });
+    it('loads workspace setup after cloud sign-in when the user has no workspaces', async () => {
+        const user = userEvent.setup();
+        let authenticated = false;
+        const fetchMock = vi.fn((input, init) => {
+            const url = String(input);
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    success: true,
+                    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,
+                        cloudAuthViaLocalProxy: false
+                    }
                 });
             }
-            if (url.includes('/api/taskforce/session/workspace')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: authenticated ? 'user-cloud-setup' : 'anonymous',
+                    workspaceId: 'default'
+                });
             }
-            if (url.includes('/api/taskforce/ui-state')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            if (url.includes('/api/taskforce/auth/login')) {
+                authenticated = true;
+                return jsonResponse({ success: true });
             }
-            if (url.includes('/api/taskforce/tasks')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: mockTasks }) });
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    workspaces: [],
+                    currentWorkspaceId: 'default'
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return jsonResponse({
+                    gate: 'ok',
+                    hasEntitlement: true,
+                    canAccessApp: true,
+                    canAccessPlans: true,
+                    message: null
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: authenticated ? 'user-cloud-setup' : 'anonymous',
+                    setupState: {
+                        globalSetupState: 'present',
+                        workspaceSetupState: authenticated ? 'missing' : 'present',
+                        runtimeMode: 'cloud',
+                        workspaceId: 'default',
+                        mode: 'core',
+                        forceSetup: false,
+                        forceGlobalSetup: false,
+                        forceWorkspaceSetup: false,
+                        workspace: null,
+                        suggestedWorkspaceName: ''
+                    },
+                    runtimeCapabilities: {
+                        runtimeMode: 'cloud',
+                        supportsCloudAuth: true,
+                        supportsAdminManagedSetupOverrides: true,
+                        supportsPackageScriptSetupOverrides: false
+                    }
+                });
+            }
+            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/workflow-templates')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ templates: [] }) });
+                return jsonResponse({ templates: [] });
             }
-            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+            return jsonResponse({});
         });
         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' }));
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=login&next=%2F'], children: _jsx(TaskforceCore, {}) }));
+        await user.type(await screen.findByPlaceholderText('Email'), 'setup@example.com');
+        await user.type(screen.getByPlaceholderText('Password'), 'Password123!');
+        await user.click(screen.getByRole('button', { name: 'Sign In' }));
         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';
+            expect(screen.getByText('Configure your new workspace.')).toBeInTheDocument();
         });
-        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);
+        expect(screen.queryByText('Resolving workspace access...')).not.toBeInTheDocument();
+        expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/config'))).toBe(true);
     });
     it('enables workspace cloud sync from local setup when signed in and checkbox is selected', async () => {
         const user = userEvent.setup();
@@ -3183,16 +4915,17 @@ describe('TaskforceCore Integration', () => {
         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();
+            expect(screen.getByText('Configure your new workspace.')).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');
+        const nameInput = screen.getByPlaceholderText('Workspace 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: 'Continue' }));
+        await user.click(screen.getByRole('button', { name: 'Create Workspace' }));
         await waitFor(() => {
             expect(screen.getByTitle(/Account/i)).toBeInTheDocument();
         });
@@ -3206,10 +4939,11 @@ describe('TaskforceCore Integration', () => {
             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);
+        expect(workspaceSyncStateBody.patch?.version).toBe(2);
+        expect(workspaceSyncStateBody.patch?.enabled).toBe(true);
+        expect(workspaceSyncStateBody.patch?.phase).toBe('provision-local');
+        expect(workspaceSyncStateBody.patch?.setupIntent).toBeNull();
+        expect(workspaceSyncStateBody.patch?.pullCursor).toBeNull();
     });
     it('creates a new cloud workspace only after guided setup submit', async () => {
         const user = userEvent.setup();
@@ -3621,7 +5355,7 @@ describe('TaskforceCore Integration', () => {
         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();
+            expect(screen.getByText('Configure your new workspace.')).toBeInTheDocument();
         });
         await waitFor(() => {
             expect(screen.getByRole('checkbox', { name: /sync to cloud after setup/i })).toBeInTheDocument();
@@ -3637,7 +5371,7 @@ describe('TaskforceCore Integration', () => {
         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.queryByText('Configure your new workspace.')).not.toBeInTheDocument();
             expect(screen.getByRole('button', { name: /add task/i })).toBeInTheDocument();
         });
         expect(cloudWorkspaceCreated).toBe(false);
@@ -3878,18 +5612,31 @@ describe('TaskforceCore Integration', () => {
         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(/Open tasks/)).toHaveTextContent(/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');
+            expect(screen.getByTitle(/Open tasks/)).toHaveTextContent(/1/);
         });
         await user.click(screen.getByTitle(/Account/i));
         expect(await screen.findByText('Sign In / Register')).toBeInTheDocument();
     });
+    it('uses an explicit cloud sign-out redirect and broader cloud logout reset path', () => {
+        const standaloneLayoutSource = fs.readFileSync(path.join(__dirname, 'components/views/StandaloneLayout.tsx'), 'utf8');
+        const useTaskforceSource = fs.readFileSync(path.join(__dirname, 'hooks/useTaskforce.ts'), 'utf8');
+        expect(standaloneLayoutSource).toContain("await logout();");
+        expect(standaloneLayoutSource).toContain("if (runtimeMode === 'cloud') {");
+        expect(standaloneLayoutSource).toContain("navigate('/login', { replace: true });");
+        expect(useTaskforceSource).toContain('const resetCloudLogoutClientState = useCallback(() => {');
+        expect(useTaskforceSource).toContain('setArchivedTasks([]);');
+        expect(useTaskforceSource).toContain('setDeletedTasks([]);');
+        expect(useTaskforceSource).toContain('setAssigneeOptions(createDefaultAssigneeOptions());');
+        expect(useTaskforceSource).toContain('setUiStateReady(false);');
+        expect(useTaskforceSource).toContain('resetCloudLogoutClientState();');
+    });
     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')) {
@@ -4758,9 +6505,10 @@ describe('TaskforceCore Integration', () => {
     it('keeps local workspace context authoritative over cloud auth session workspace id', async () => {
         const useTaskforcePath = path.join(process.cwd(), 'src/hooks/useTaskforce.ts');
         const useTaskforceSource = fs.readFileSync(useTaskforcePath, 'utf8');
-        expect(useTaskforceSource).toContain("const keepLocalWorkspaceContext = runtimeMode === 'local' || authOnlyCloudMode;");
-        expect(useTaskforceSource).toContain('Local runtime resolves workspace identity from local DB via /api/taskforce/config.');
-        expect(useTaskforceSource).toContain('Do not override it from cloud auth session payloads.');
+        expect(useTaskforceSource).toContain("const authOnlyCloudMode = !isCloudHost && Boolean(normalizedCloudAuthBaseUrl) && !normalizedApiBaseUrl;");
+        expect(useTaskforceSource).toContain('Local runtime workspace identity must be sourced from local DB (/api/taskforce/config),');
+        expect(useTaskforceSource).toContain('not from persisted browser context or cloud session payloads.');
+        expect(useTaskforceSource).toContain("if (initialRuntimeMode === 'local') return 'default';");
     });
     it.skip('blocks local cloud-sync pull/apply when workspaceId remains default', async () => {
         const fetchMock = vi.fn((url, init) => {