@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/components/views/PlansPage.test.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { MemoryRouter } from 'react-router-dom';
 import { PlansPage } from './PlansPage';
+import { ACCOUNT_PROFILE_SUMMARY_PATH, invalidateAccountProfileSummaryCache } from '../../utils/accountProfileSummaryCache';
 vi.mock('./PlanComparisonPage', () => ({
-    PlanComparisonPage: ({ heading, statusBanner, topActions, onSelectPlan, onBack, backLabel, backDisabled }) => (_jsxs("div", { children: [_jsx("h1", { children: heading }), statusBanner?.message ? _jsx("div", { "data-status-type": statusBanner.type, children: statusBanner.message }) : null, topActions, onSelectPlan ? (_jsx("button", { onClick: () => onSelectPlan({
+    PlanComparisonPage: ({ heading, pricingEndpoint, statusBanner, topActions, onSelectPlan, onBack, backLabel, backDisabled }) => (_jsxs("div", { children: [_jsx("h1", { children: heading }), pricingEndpoint ? _jsx("div", { "data-testid": "pricing-endpoint", children: pricingEndpoint }) : null, statusBanner?.message ? _jsx("div", { "data-status-type": statusBanner.type, children: statusBanner.message }) : null, topActions, onSelectPlan ? (_jsx("button", { onClick: () => onSelectPlan({
                     planId: 'free',
                     planVersionId: 'free-v1',
                     interval: 'month',
@@ -14,56 +15,439 @@ vi.mock('./PlanComparisonPage', () => ({
 }));
 describe('PlansPage', () => {
     afterEach(() => {
+        vi.useRealTimers();
         vi.unstubAllGlobals();
     });
-    it('shows recovery messaging instead of false checkout success when confirmation fails', async () => {
-        const fetchMock = vi.fn()
-            .mockResolvedValueOnce({
+    it('builds the pricing endpoint through resolveCloudAuthUrl', async () => {
+        vi.stubGlobal('fetch', vi.fn(async () => ({
             ok: true,
-            json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
-                entitlementState: 'checkout_pending',
-                gate: 'checkout_pending',
-                message: 'Complete checkout to continue.'
-            })
-        })
-            .mockResolvedValueOnce({
-            ok: false,
-            json: async () => ({
-                error: 'Checkout session has not completed yet.',
-                code: 'CHECKOUT_SESSION_INCOMPLETE'
-            })
-        })
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
-                entitlementState: 'checkout_pending',
-                gate: 'plan_selection_required',
-                message: 'Your previous checkout expired. Choose a plan to continue.',
-                planSelectionRequired: true
-            })
+            json: async () => ({})
+        })));
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: false, runtimeMode: "local", authSessionResolved: true, apiBaseUrl: "https://performance-app.taskforcehq.ai/api", resolveCloudAuthUrl: (path) => `/api/proxy?path=${encodeURIComponent(path)}` }) }));
+        expect(await screen.findByTestId('pricing-endpoint')).toHaveTextContent('/api/proxy?path=%2Fapi%2Ftaskforce%2Fpublic%2Fpricing');
+    });
+    it('shows recovery messaging only after bounded retries are exhausted', async () => {
+        vi.useFakeTimers();
+        let profileSummaryCalls = 0;
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls <= 2) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            entitlementState: 'checkout_pending',
+                            gate: 'checkout_pending',
+                            message: 'Complete checkout to continue.'
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        entitlementState: 'pending_plan_selection',
+                        gate: 'plan_selection_required',
+                        message: 'Your previous checkout expired. Choose a plan to continue.',
+                        planSelectionRequired: true
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: false,
+                    status: 409,
+                    json: async () => ({
+                        error: 'Checkout session has not completed yet.',
+                        code: 'CHECKOUT_SESSION_INCOMPLETE'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
         });
         vi.stubGlobal('fetch', fetchMock);
         render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_123'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(screen.getByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        await act(async () => {
+            await Promise.resolve();
+        });
+        expect(confirmCalls).toBe(1);
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(50000);
+        });
+        expect(confirmCalls).toBeGreaterThanOrEqual(12);
+        expect(screen.getByText('Your previous checkout expired. Choose a plan to continue.')).toBeInTheDocument();
+        expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
+    }, 10000);
+    it('retries checkout confirmation when the first confirm is incomplete and later succeeds', async () => {
+        let profileSummaryCalls = 0;
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls <= 2) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            entitlementState: 'checkout_pending',
+                            gate: 'checkout_pending',
+                            message: 'Complete checkout to continue.'
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        billingInterval: 'month',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                if (confirmCalls === 1) {
+                    return {
+                        ok: false,
+                        status: 409,
+                        json: async () => ({
+                            error: 'Checkout session has not completed yet.',
+                            code: 'CHECKOUT_SESSION_INCOMPLETE'
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_retry_success'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
         expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
-        expect(await screen.findByText('Your previous checkout expired. Choose a plan to continue.')).toBeInTheDocument();
+        expect(await screen.findByText('Checkout completed successfully.')).toBeInTheDocument();
+        expect(confirmCalls).toBe(2);
+    }, 10000);
+    it('treats an active entitlement summary as checkout success even when confirm still reports incomplete', async () => {
+        let profileSummaryCalls = 0;
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls === 1) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            entitlementState: 'checkout_pending',
+                            gate: 'checkout_pending',
+                            message: 'Complete checkout to continue.'
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        billingInterval: 'month',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: false,
+                    status: 409,
+                    json: async () => ({
+                        error: 'Checkout session is still finalizing your plan.',
+                        code: 'CHECKOUT_SESSION_INCOMPLETE'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_summary_settled'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        expect(await screen.findByText('Checkout completed successfully.')).toBeInTheDocument();
+        expect(confirmCalls).toBe(1);
+    }, 10000);
+    it('does not treat an already-active account as settled until the requested interval change is visible', async () => {
+        vi.useFakeTimers();
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        billingInterval: 'month',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: false,
+                    status: 409,
+                    json: async () => ({
+                        error: 'Checkout session is still finalizing your plan.',
+                        code: 'CHECKOUT_SESSION_INCOMPLETE'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_existing_active_interval&planId=basic&planVersionId=basic-v1&interval=year'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(screen.getByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        await act(async () => {
+            await Promise.resolve();
+        });
+        expect(confirmCalls).toBe(1);
+        expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(50000);
+        });
+        expect(confirmCalls).toBeGreaterThanOrEqual(12);
+        expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
+    }, 10000);
+    it('does not retry checkout confirmation for account mismatch responses', async () => {
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        entitlementState: 'checkout_pending',
+                        gate: 'checkout_pending',
+                        message: 'Complete checkout to continue.'
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: false,
+                    status: 403,
+                    json: async () => ({
+                        error: 'Checkout session does not belong to the current account.',
+                        code: 'CHECKOUT_SESSION_ACCOUNT_MISMATCH'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_wrong_account'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u1", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        await waitFor(() => {
+            expect(confirmCalls).toBe(1);
+        });
+        await act(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 1200));
+        });
+        expect(confirmCalls).toBe(1);
         expect(screen.queryByText('Checkout completed successfully.')).not.toBeInTheDocument();
+        expect(screen.getByText('Checkout session does not belong to the current account.')).toBeInTheDocument();
+        expect(screen.queryByText('Complete checkout to continue.')).not.toBeInTheDocument();
+    }, 10000);
+    it('attempts checkout confirmation immediately when the user is already authenticated even if auth session is still resolving', async () => {
+        let profileSummaryCalls = 0;
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls <= 2) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            entitlementState: 'checkout_pending',
+                            gate: 'checkout_pending',
+                            message: 'Complete checkout to continue.'
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const view = render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_auth_wait'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u_auth", runtimeMode: "cloud", authSessionResolved: false, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
         await waitFor(() => {
-            expect(fetchMock).toHaveBeenNthCalledWith(2, '/api/taskforce/billing/checkout-session/confirm', expect.objectContaining({
-                method: 'POST'
-            }));
+            expect(confirmCalls).toBe(1);
         });
     });
+    it('waits to confirm checkout when auth is still unresolved and the user is not yet authenticated', async () => {
+        let profileSummaryCalls = 0;
+        let confirmCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                return {
+                    ok: true,
+                    json: async () => ({
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        entitlementState: 'checkout_pending',
+                        gate: 'checkout_pending',
+                        message: 'Complete checkout to continue.'
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const view = render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_auth_wait'], children: _jsx(PlansPage, { isAuthenticated: false, authUserId: "u_auth", runtimeMode: "cloud", authSessionResolved: false, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Checkout completed successfully. Finalizing your plan...')).toBeInTheDocument();
+        expect(confirmCalls).toBe(0);
+        view.rerender(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_auth_wait'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u_auth", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/billing/checkout-session/confirm'))).toBe(true);
+        });
+    });
+    it('restarts checkout confirmation after a mid-flight rerender before the first confirm attempt', async () => {
+        let confirmCalls = 0;
+        let profileSummaryCalls = 0;
+        let releaseBlockedProfileSummaries = false;
+        const blockedProfileSummaryResolvers = [];
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (!releaseBlockedProfileSummaries) {
+                    return await new Promise((resolve) => {
+                        blockedProfileSummaryResolvers.push(resolve);
+                    });
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'checkout_pending',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        gate: 'checkout_pending',
+                        message: 'Complete checkout to continue.'
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                confirmCalls += 1;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const firstResolveCloudAuthUrl = (path) => path;
+        const secondResolveCloudAuthUrl = (path) => path;
+        const view = render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_rerender'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u_rerender", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: firstResolveCloudAuthUrl }) }));
+        await waitFor(() => {
+            expect(profileSummaryCalls).toBeGreaterThan(0);
+        });
+        view.rerender(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_rerender'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u_rerender", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: secondResolveCloudAuthUrl }) }));
+        releaseBlockedProfileSummaries = true;
+        for (const resolve of blockedProfileSummaryResolvers.splice(0)) {
+            resolve({
+                ok: true,
+                json: async () => ({
+                    entitlementState: 'checkout_pending',
+                    planId: 'basic',
+                    planVersionId: 'basic-v1',
+                    gate: 'checkout_pending',
+                    message: 'Complete checkout to continue.'
+                })
+            });
+        }
+        await waitFor(() => {
+            expect(confirmCalls).toBe(1);
+        });
+        expect(await screen.findByText('Checkout completed successfully.')).toBeInTheDocument();
+    });
     it('shows conflict-specific recovery messaging when the account lands on plans already blocked', async () => {
         const fetchMock = vi.fn()
             .mockResolvedValueOnce({
             ok: true,
             json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
+                planId: 'basic',
+                planVersionId: 'basic-v1',
                 entitlementState: 'pending_plan_selection',
                 gate: 'plan_selection_required',
                 message: 'Choose a plan to continue.',
@@ -80,8 +464,8 @@ describe('PlansPage', () => {
             .mockResolvedValueOnce({
             ok: true,
             json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
+                planId: 'basic',
+                planVersionId: 'basic-v1',
                 entitlementState: 'checkout_pending',
                 gate: 'checkout_pending',
                 message: 'Complete checkout to continue.'
@@ -90,8 +474,8 @@ describe('PlansPage', () => {
             .mockResolvedValueOnce({
             ok: true,
             json: async () => ({
-                planId: 'pro',
-                planVersionId: 'pro-v1',
+                planId: 'basic',
+                planVersionId: 'basic-v1',
                 entitlementState: 'pending_plan_selection',
                 gate: 'plan_selection_required',
                 message: 'Choose a plan to continue.',
@@ -132,7 +516,8 @@ describe('PlansPage', () => {
         });
         vi.stubGlobal('fetch', fetchMock);
         render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&gate=plan_selection_required'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u4", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: onContinueToTaskforce }) }));
-        expect(await screen.findByText('Choose a plan to continue.')).toBeInTheDocument();
+        await screen.findByRole('heading', { name: 'Subscription Plans' });
+        expect(screen.queryByText('Choose a plan to continue.')).not.toBeInTheDocument();
         fireEvent.click(screen.getByRole('button', { name: 'Select Free Plan' }));
         await waitFor(() => {
             expect(onContinueToTaskforce).toHaveBeenCalledTimes(1);
@@ -152,6 +537,172 @@ describe('PlansPage', () => {
         vi.stubGlobal('fetch', fetchMock);
         render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&gate=plan_selection_required'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u5", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
         expect(await screen.findByRole('button', { name: 'Back to App' })).toBeDisabled();
-        expect(screen.getByText('Choose a plan to continue.')).toHaveAttribute('data-status-type', 'info');
+        expect(screen.queryByText('Choose a plan to continue.')).not.toBeInTheDocument();
+    });
+    it('does not auto-continue after an in-place paid interval update for an already active account', async () => {
+        const onContinueToTaskforce = vi.fn();
+        let profileSummaryCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls <= 2) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            entitlementState: 'active',
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            gate: 'ok',
+                            message: null
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'basic',
+                        planVersionId: 'basic-v1',
+                        billingInterval: 'year',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session')) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        checkoutState: 'updated',
+                        message: 'Your subscription was updated successfully.'
+                    })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=start&planId=basic&planVersionId=basic-v1&interval=year'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u6", runtimeMode: "local", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: onContinueToTaskforce }) }));
+        expect(await screen.findByText('Your subscription was updated successfully.')).toBeInTheDocument();
+        expect(onContinueToTaskforce).not.toHaveBeenCalled();
+    });
+    it('does not auto-continue after confirming checkout when the account was already active', async () => {
+        const onContinueToTaskforce = vi.fn();
+        let profileSummaryCalls = 0;
+        const fetchMock = vi.fn(async (url) => {
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                profileSummaryCalls += 1;
+                if (profileSummaryCalls <= 2) {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            entitlementState: 'active',
+                            planId: 'basic',
+                            planVersionId: 'basic-v1',
+                            gate: 'ok',
+                            message: null
+                        })
+                    };
+                }
+                return {
+                    ok: true,
+                    json: async () => ({
+                        entitlementState: 'active',
+                        planId: 'team-5',
+                        planVersionId: 'team-5-v1',
+                        gate: 'ok',
+                        message: null
+                    })
+                };
+            }
+            if (url.includes('/api/taskforce/billing/checkout-session/confirm')) {
+                return {
+                    ok: true,
+                    json: async () => ({ success: true })
+                };
+            }
+            return {
+                ok: true,
+                json: async () => ({})
+            };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=success&session_id=cs_test_existing_active'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u7", runtimeMode: "local", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: onContinueToTaskforce }) }));
+        expect(await screen.findByText('Checkout completed successfully.')).toBeInTheDocument();
+        expect(onContinueToTaskforce).not.toHaveBeenCalled();
+    });
+    it('shows trial-specific messaging while still allowing return to Taskforce', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'trialing',
+                planId: 'starter',
+                planVersionId: 'starter-v1',
+                gate: 'ok',
+                trialEnd: '2026-05-01T12:00:00.000Z'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u8", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: vi.fn() }) }));
+        expect(await screen.findByText(/Your trial is active through/)).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Take Me to Taskforce' })).toBeEnabled();
+    });
+    it('does not claim an expired trial is still active through a past date', async () => {
+        const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(new Date('2026-04-20T12:00:00.000Z').getTime());
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'trialing',
+                planId: 'starter',
+                planVersionId: 'starter-v1',
+                gate: 'ok',
+                trialEnd: '2026-04-12T16:09:09.000Z'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        invalidateAccountProfileSummaryCache(ACCOUNT_PROFILE_SUMMARY_PATH, { identityKey: 'u8' });
+        try {
+            render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u8", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path, onContinueToTaskforce: vi.fn() }) }));
+            expect(await screen.findByText('Your trial end date has passed. Billing status is updating.')).toBeInTheDocument();
+            expect(screen.queryByText(/Your trial is active through/)).not.toBeInTheDocument();
+        }
+        finally {
+            nowSpy.mockRestore();
+        }
+    });
+    it('shows suspended accounts a billing-recovery message and keeps return blocked', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'suspended',
+                planId: 'pro',
+                planVersionId: 'pro-v1',
+                gate: 'missing_entitlement',
+                stripeCustomerId: 'cus_123'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u9", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Your access is suspended because billing needs attention. Update billing to restore access.')).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Back to App' })).toBeDisabled();
+        expect(screen.getByText('Your access is suspended because billing needs attention. Update billing to restore access.')).toHaveAttribute('data-status-type', 'error');
+    });
+    it('shows canceled accounts reactivation messaging instead of generic inactive copy', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                entitlementState: 'canceled',
+                planId: 'pro',
+                planVersionId: 'pro-v1',
+                gate: 'missing_entitlement',
+                message: 'This generic message should be ignored.'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u10", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
+        expect(await screen.findByText('Your access has ended. Choose a plan to reactivate your workspace.')).toBeInTheDocument();
+        expect(screen.queryByText('This generic message should be ignored.')).not.toBeInTheDocument();
     });
 });