@taskforcehq/taskforce 0.3.311 → 0.3.313

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

@@ -1,710 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-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, variant, pricingEndpoint, statusBanner, topActions, onSelectPlan, onBack, backLabel, backDisabled }) => (_jsxs("div", { children: [_jsx("h1", { children: heading }), variant ? _jsx("div", { "data-testid": "plans-variant", children: variant }) : null, 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',
-                    pricingType: 'free',
-                    pricingAudience: 'public',
-                    isCurrentPlan: false
-                }), children: "Select Free Plan" })) : null, onBack ? (_jsx("button", { onClick: onBack, disabled: backDisabled, children: backLabel || 'Back' })) : null] }))
-}));
-describe('PlansPage', () => {
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-    });
-    it('builds the pricing endpoint through resolveCloudAuthUrl', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: 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');
-        expect(screen.getByTestId('plans-variant')).toHaveTextContent('site');
-    });
-    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('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(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: 'basic',
-                planVersionId: 'basic-v1',
-                entitlementState: 'pending_plan_selection',
-                gate: 'plan_selection_required',
-                message: 'Choose a plan to continue.',
-                billingConflictCode: 'CHECKOUT_SESSION_SUPERSEDED',
-                planSelectionRequired: true
-            })
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u2", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
-        expect(await screen.findByText('A newer checkout replaced your previous checkout. Choose a plan to continue.')).toBeInTheDocument();
-    });
-    it('shows conflict-specific recovery messaging after checkout cancel when the latest attempt expired', async () => {
-        const fetchMock = vi.fn()
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                planId: 'basic',
-                planVersionId: 'basic-v1',
-                entitlementState: 'checkout_pending',
-                gate: 'checkout_pending',
-                message: 'Complete checkout to continue.'
-            })
-        })
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                planId: 'basic',
-                planVersionId: 'basic-v1',
-                entitlementState: 'pending_plan_selection',
-                gate: 'plan_selection_required',
-                message: 'Choose a plan to continue.',
-                billingConflictCode: 'CHECKOUT_SESSION_EXPIRED',
-                planSelectionRequired: true
-            })
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&checkout=cancel'], children: _jsx(PlansPage, { isAuthenticated: true, authUserId: "u3", runtimeMode: "cloud", authSessionResolved: true, resolveCloudAuthUrl: (path) => path }) }));
-        expect(await screen.findByText('Your previous checkout expired. Choose a plan to continue.')).toBeInTheDocument();
-    });
-    it('auto-continues after a free plan grant and exposes a taskforce CTA once access is active', async () => {
-        const onContinueToTaskforce = vi.fn();
-        const fetchMock = vi.fn()
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                entitlementState: 'pending_plan_selection',
-                gate: 'plan_selection_required',
-                message: 'Choose a plan to continue.'
-            })
-        })
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                checkoutState: 'free'
-            })
-        })
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                entitlementState: 'active',
-                planId: 'free',
-                planVersionId: 'free-v1',
-                gate: 'ok',
-                message: null
-            })
-        });
-        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 }) }));
-        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);
-        });
-        expect(screen.getByRole('button', { name: 'Take Me to Taskforce' })).toBeInTheDocument();
-    });
-    it('disables the back action while the account is still entitlement-blocked', async () => {
-        const fetchMock = vi.fn()
-            .mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                entitlementState: 'pending_plan_selection',
-                gate: 'plan_selection_required',
-                message: 'Choose a plan to continue.'
-            })
-        });
-        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.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-06-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();
-    });
-});