@taskforcehq/taskforce 0.3.304 → 0.3.305

package/dist/components/task/TaskKanban.js

@@ -53,7 +53,8 @@ export function TaskKanban({ tasks, columns: kanbanColumns, groupBy, searchQuery
     // Sensors
     const sensors = useSensors(useSensor(PointerSensor, {
         activationConstraint: {
-            distance: 5, // Prevent accidental drags
+            // Give normal clicks a bit more tolerance so slight trackpad drift still opens the task.
+            distance: 10,
         },
     }), useSensor(KeyboardSensor, {
         coordinateGetter: sortableKeyboardCoordinates,

package/dist/components/views/PlanComparisonPage.js

@@ -3,6 +3,7 @@ import { useEffect, useMemo, useState } from 'react';
 import { CheckCircle2, Loader2 } from 'lucide-react';
 import taskforceStyles from '../../Taskforce.module.css';
 import styles from './PlansPage.module.css';
+import { isCommercialEntitlementActive } from '../../utils/commercialLifecyclePresentation';
 function isDebugModeEnabled() {
     const runtimeOverride = globalThis.__DEBUG_MODE__;
     if (typeof runtimeOverride === 'boolean')
@@ -60,10 +61,6 @@ function getPlanSortRank(plan) {
         return Math.min(...numericAmounts);
     return Number.POSITIVE_INFINITY;
 }
-function isActiveEntitlementState(raw) {
-    const value = String(raw || '').trim().toLowerCase();
-    return value === 'active' || value === 'trialing' || value === 'grace';
-}
 export function PlanComparisonPage({ heading, subtitle, variant = 'app', chrome, footer, isAuthenticated, authSessionResolved = true, currentPlanId, currentPlanVersionId, currentEntitlementState, canManageCurrentPlan = true, pricingEndpoint, statusBanner, onBack, backLabel, backDisabled = false, topActions, shellOwnsScroll = false, showPageBackButton = true, fallbackPricingSource = null, onSelectPlan }) {
     const [plans, setPlans] = useState([]);
     const [pricingSource, setPricingSource] = useState(null);
@@ -138,11 +135,11 @@ export function PlanComparisonPage({ heading, subtitle, variant = 'app', chrome,
                             const hasMonth = isSelectablePrice(monthPrice);
                             const hasYear = isSelectablePrice(yearPrice);
                             const planVersionId = String(plan.defaultVersion?.planVersionId || '').trim();
-                            const isCurrent = Boolean(planVersionId
+                            const hasActiveEntitlement = isCommercialEntitlementActive(currentEntitlementState);
+                            const isCurrent = hasActiveEntitlement && (Boolean(planVersionId
                                 && currentPlanVersionId
-                                && currentPlanVersionId === planVersionId
-                                && isActiveEntitlementState(currentEntitlementState)) || (!currentPlanVersionId
-                                && Boolean(currentPlanId && currentPlanId === plan.planId));
+                                && currentPlanVersionId === planVersionId) || (!currentPlanVersionId
+                                && Boolean(currentPlanId && currentPlanId === plan.planId)));
                             const defaultInterval = hasMonth ? 'month' : (hasYear ? 'year' : null);
                             const defaultPrice = defaultInterval === 'year' ? yearPrice : monthPrice;
                             const canSelectCard = Boolean(planVersionId) && (isCurrent ? canManageCurrentPlan : Boolean(defaultInterval));

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

@@ -15,11 +15,11 @@ describe('PlanComparisonPage', () => {
                 },
                 plans: [
                     {
-                        planId: 'starter',
-                        displayName: 'Starter',
+                        planId: 'free',
+                        displayName: 'Free',
                         status: 'active',
                         defaultVersion: {
-                            planVersionId: 'starter-v1',
+                            planVersionId: 'free-v1',
                             versionNumber: 1,
                             seatLimit: null,
                             metadata: {}
@@ -31,19 +31,19 @@ describe('PlanComparisonPage', () => {
                         }
                     },
                     {
-                        planId: 'collab',
-                        displayName: 'Collab',
+                        planId: 'team-5',
+                        displayName: 'Team 5',
                         status: 'active',
                         defaultVersion: {
-                            planVersionId: 'collab-v2',
+                            planVersionId: 'team-5-v2',
                             versionNumber: 2,
                             seatLimit: 5,
                             metadata: {}
                         },
                         features: [],
                         pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_collab_month', unitAmount: 2000, currency: 'usd', interval: 'month' },
-                            year: { pricingType: 'stripe', stripePriceId: 'price_collab_year', unitAmount: 20000, currency: 'usd', interval: 'year' }
+                            month: { pricingType: 'stripe', stripePriceId: 'price_team_5_month', unitAmount: 2000, currency: 'usd', interval: 'month' },
+                            year: { pricingType: 'stripe', stripePriceId: 'price_team_5_year', unitAmount: 20000, currency: 'usd', interval: 'year' }
                         }
                     }
                 ]
@@ -66,11 +66,11 @@ describe('PlanComparisonPage', () => {
             json: async () => ({
                 plans: [
                     {
-                        planId: 'starter',
-                        displayName: 'Starter',
+                        planId: 'free',
+                        displayName: 'Free',
                         status: 'active',
                         defaultVersion: {
-                            planVersionId: 'starter-v1',
+                            planVersionId: 'free-v1',
                             versionNumber: 1,
                             seatLimit: null,
                             metadata: {}
@@ -93,7 +93,17 @@ describe('PlanComparisonPage', () => {
         expect(screen.queryByText('Pricing source: production (cloud)')).not.toBeInTheDocument();
     });
     it('does not mark a plan current when only the plan id matches but the version does not', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "collab", currentPlanVersionId: "collab-v1", currentEntitlementState: "active", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
+        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "team-5", currentPlanVersionId: "team-5-v1", currentEntitlementState: "active", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
+        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+        expect(screen.queryByText('Current Plan')).not.toBeInTheDocument();
+    });
+    it('marks a trialing entitlement as the current plan', async () => {
+        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "team-5", currentPlanVersionId: "team-5-v2", currentEntitlementState: "trialing", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
+        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+        expect(screen.getByText('Current Plan')).toBeInTheDocument();
+    });
+    it('does not mark a canceled entitlement as current through the plan-id fallback path', async () => {
+        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "team-5", currentPlanVersionId: null, currentEntitlementState: "canceled", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
         expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
         expect(screen.queryByText('Current Plan')).not.toBeInTheDocument();
     });
@@ -105,16 +115,16 @@ describe('PlanComparisonPage', () => {
         const onSelectPlan = vi.fn();
         render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
         await screen.findByRole('heading', { name: 'Subscription Plans' });
-        const starterHeading = screen.getByRole('heading', { name: 'Starter' });
-        const starterCard = starterHeading.closest('[role="button"]');
-        expect(starterCard).toBeTruthy();
-        expect(within(starterCard).getByText('$0.00')).toBeInTheDocument();
-        expect(within(starterCard).getByText('/ month')).toBeInTheDocument();
-        fireEvent.click(starterCard);
+        const freeHeading = screen.getByRole('heading', { name: 'Free' });
+        const freeCard = freeHeading.closest('[role="button"]');
+        expect(freeCard).toBeTruthy();
+        expect(within(freeCard).getByText('$0.00')).toBeInTheDocument();
+        expect(within(freeCard).getByText('/ month')).toBeInTheDocument();
+        fireEvent.click(freeCard);
         await waitFor(() => {
             expect(onSelectPlan).toHaveBeenCalledWith({
-                planId: 'starter',
-                planVersionId: 'starter-v1',
+                planId: 'free',
+                planVersionId: 'free-v1',
                 interval: 'month',
                 pricingType: 'free',
                 isCurrentPlan: false
@@ -123,7 +133,7 @@ describe('PlanComparisonPage', () => {
     });
     it('does not trigger current-plan actions when the current plan is not Stripe-managed', async () => {
         const onSelectPlan = vi.fn();
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "starter", currentPlanVersionId: "starter-v1", currentEntitlementState: "active", canManageCurrentPlan: false, onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
+        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "free", currentPlanVersionId: "free-v1", currentEntitlementState: "active", canManageCurrentPlan: false, onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
         await screen.findByRole('heading', { name: 'Subscription Plans' });
         const currentButton = screen.getByRole('button', { name: 'Current Plan' });
         expect(currentButton).toBeDisabled();
@@ -139,11 +149,11 @@ describe('PlanComparisonPage', () => {
                 },
                 plans: [
                     {
-                        planId: 'starter',
-                        displayName: 'Starter',
+                        planId: 'free',
+                        displayName: 'Free',
                         status: 'active',
                         defaultVersion: {
-                            planVersionId: 'starter-v1',
+                            planVersionId: 'free-v1',
                             versionNumber: 1,
                             seatLimit: null,
                             metadata: {}
@@ -159,7 +169,7 @@ describe('PlanComparisonPage', () => {
         });
         vi.stubGlobal('fetch', fetchMock);
         render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, pricingEndpoint: "https://performance-app.example/api/taskforce/public/pricing", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Starter' })).toBeInTheDocument();
+        expect(await screen.findByRole('heading', { name: 'Free' })).toBeInTheDocument();
         expect(fetchMock).toHaveBeenCalledTimes(1);
         expect(fetchMock).toHaveBeenCalledWith('https://performance-app.example/api/taskforce/public/pricing', {
             method: 'GET',
@@ -177,27 +187,27 @@ describe('PlanComparisonPage', () => {
                 },
                 plans: [
                     {
-                        planId: 'enterprise',
-                        displayName: 'Enterprise',
+                        planId: 'team-5',
+                        displayName: 'Team 5',
                         status: 'active',
                         defaultVersion: {
-                            planVersionId: 'enterprise-v3',
+                            planVersionId: 'team-5-v2',
                             versionNumber: 3,
-                            seatLimit: 100,
+                            seatLimit: 5,
                             metadata: {}
                         },
                         features: [],
                         pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_enterprise_month', unitAmount: 12000, currency: 'usd', interval: 'month' },
-                            year: { pricingType: 'stripe', stripePriceId: 'price_enterprise_year', unitAmount: 120000, currency: 'usd', interval: 'year' }
+                            month: { pricingType: 'stripe', stripePriceId: 'price_team_5_month', unitAmount: 12000, currency: 'usd', interval: 'month' },
+                            year: { pricingType: 'stripe', stripePriceId: 'price_team_5_year', unitAmount: 120000, currency: 'usd', interval: 'year' }
                         }
                     },
                     {
-                        planId: 'starter',
-                        displayName: 'Starter',
+                        planId: 'free',
+                        displayName: 'Free',
                         status: 'active',
                         defaultVersion: {
-                            planVersionId: 'starter-v1',
+                            planVersionId: 'free-v1',
                             versionNumber: 1,
                             seatLimit: null,
                             metadata: {}
@@ -209,19 +219,19 @@ describe('PlanComparisonPage', () => {
                         }
                     },
                     {
-                        planId: 'pro',
-                        displayName: 'Pro',
+                        planId: 'basic',
+                        displayName: 'Basic',
                         status: 'active',
                         defaultVersion: {
-                            planVersionId: 'pro-v2',
+                            planVersionId: 'basic-v1',
                             versionNumber: 2,
-                            seatLimit: 10,
+                            seatLimit: 1,
                             metadata: {}
                         },
                         features: [],
                         pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_pro_month', unitAmount: 3000, currency: 'usd', interval: 'month' },
-                            year: { pricingType: 'stripe', stripePriceId: 'price_pro_year', unitAmount: 30000, currency: 'usd', interval: 'year' }
+                            month: { pricingType: 'stripe', stripePriceId: 'price_basic_month', unitAmount: 3000, currency: 'usd', interval: 'month' },
+                            year: { pricingType: 'stripe', stripePriceId: 'price_basic_year', unitAmount: 30000, currency: 'usd', interval: 'year' }
                         }
                     }
                 ]
@@ -231,7 +241,7 @@ describe('PlanComparisonPage', () => {
         render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
         await screen.findByRole('heading', { name: 'Subscription Plans' });
         const planNames = screen.getAllByRole('heading', { level: 3 }).map((node) => node.textContent);
-        expect(planNames).toEqual(['Starter', 'Pro', 'Enterprise']);
+        expect(planNames).toEqual(['Free', 'Basic', 'Team 5']);
     });
     it('defaults to the same-origin pricing endpoint', async () => {
         const fetchMock = vi.fn().mockResolvedValue({

package/dist/components/views/PlansPage.js

@@ -7,18 +7,15 @@ import { PlanComparisonPage } from './PlanComparisonPage';
 import { AppShellHeader } from './AppShellHeader';
 import { resolveTaskforceCloudEnvironmentFromBaseUrl } from '../../config/cloudEnvironment';
 import { ACCOUNT_PROFILE_SUMMARY_PATH, invalidateAccountProfileSummaryCache, loadAccountProfileSummaryCached } from '../../utils/accountProfileSummaryCache';
+import { isCommercialEntitlementActive, resolveCommercialLifecyclePresentation } from '../../utils/commercialLifecyclePresentation';
 const TRANSIENT_CHECKOUT_QUERY_CLEAR_DELAY_MS = 1600;
-const ACTIVE_ENTITLEMENT_STATES = new Set(['active', 'trialing', 'grace']);
-const GATE_MESSAGES = {
-    planSelectionRequired: 'Choose a plan to continue.',
-    checkoutPending: 'Complete checkout to continue.',
-    misconfigured: 'Onboarding policy is misconfigured. Contact support or a system administrator.',
-    missingEntitlement: 'No entitlement is linked to this account.'
-};
-const BILLING_CONFLICT_MESSAGES = {
-    CHECKOUT_SESSION_EXPIRED: 'Your previous checkout expired. Choose a plan to continue.',
-    CHECKOUT_SESSION_SUPERSEDED: 'A newer checkout replaced your previous checkout. Choose a plan to continue.'
-};
+const CHECKOUT_CONFIRM_RETRY_DELAYS_MS = [0, 500, 1000, 2000];
+function shouldRetryCheckoutConfirmation(statusCode, errorCode) {
+    if (statusCode === 401) {
+        return true;
+    }
+    return String(errorCode || '').trim().toUpperCase() === 'CHECKOUT_SESSION_INCOMPLETE';
+}
 function parseInterval(raw) {
     return raw === 'year' ? 'year' : 'month';
 }
@@ -45,6 +42,7 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
     const [actionBusy, setActionBusy] = useState(false);
     const [feedback, setFeedback] = useState(null);
     const checkoutStartRan = useRef(false);
+    const checkoutSuccessHandledRef = useRef(null);
     const transientQueryClearTimeoutRef = useRef(null);
     const query = useMemo(() => new URLSearchParams(location.search), [location.search]);
     const checkoutState = String(query.get('checkout') || '').trim().toLowerCase();
@@ -89,32 +87,9 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
         ].map((value) => String(value || '').trim()).filter((value, index, all) => value && all.indexOf(value) === index);
         return endpoints;
     }, [normalizedApiBaseUrl]);
-    const hasResolvedActiveEntitlement = useMemo(() => {
-        const entitlementState = String(accountProfileSummary?.entitlementState || '').trim().toLowerCase();
-        return ACTIVE_ENTITLEMENT_STATES.has(entitlementState);
-    }, [accountProfileSummary?.entitlementState]);
-    const gateMessage = useMemo(() => {
-        if (hasResolvedActiveEntitlement)
-            return null;
-        const billingConflictCode = String(accountProfileSummary?.billingConflictCode || '').trim().toUpperCase();
-        if (billingConflictCode === 'CHECKOUT_SESSION_EXPIRED')
-            return BILLING_CONFLICT_MESSAGES.CHECKOUT_SESSION_EXPIRED;
-        if (billingConflictCode === 'CHECKOUT_SESSION_SUPERSEDED')
-            return BILLING_CONFLICT_MESSAGES.CHECKOUT_SESSION_SUPERSEDED;
-        const summaryMessage = String(accountProfileSummary?.message || '').trim();
-        if (summaryMessage)
-            return summaryMessage;
-        const effectiveGateState = String(accountProfileSummary?.gate || gateState || '').trim().toLowerCase();
-        if (effectiveGateState === 'plan_selection_required')
-            return GATE_MESSAGES.planSelectionRequired;
-        if (effectiveGateState === 'checkout_pending')
-            return GATE_MESSAGES.checkoutPending;
-        if (effectiveGateState === 'misconfigured')
-            return GATE_MESSAGES.misconfigured;
-        if (effectiveGateState === 'missing_entitlement')
-            return GATE_MESSAGES.missingEntitlement;
-        return null;
-    }, [accountProfileSummary?.billingConflictCode, accountProfileSummary?.gate, accountProfileSummary?.message, gateState, hasResolvedActiveEntitlement]);
+    const lifecyclePresentation = useMemo(() => resolveCommercialLifecyclePresentation(accountProfileSummary, gateState), [accountProfileSummary, gateState]);
+    const hasResolvedActiveEntitlement = useMemo(() => lifecyclePresentation.allowReturnToApp, [lifecyclePresentation.allowReturnToApp]);
+    const gateMessage = useMemo(() => lifecyclePresentation.message, [lifecyclePresentation.message]);
     const clearTransientQueryState = useCallback(() => {
         const next = new URLSearchParams(location.search);
         next.delete('checkout');
@@ -157,30 +132,19 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
         }
     }, [authUserId, buildCloudBillingUrl, isAuthenticated, onAccountProfileSummaryChange]);
     const resolveRecoveryMessage = useCallback((summary, fallback) => {
-        const billingConflictCode = String(summary?.billingConflictCode || '').trim().toUpperCase();
-        if (billingConflictCode === 'CHECKOUT_SESSION_EXPIRED')
-            return BILLING_CONFLICT_MESSAGES.CHECKOUT_SESSION_EXPIRED;
-        if (billingConflictCode === 'CHECKOUT_SESSION_SUPERSEDED')
-            return BILLING_CONFLICT_MESSAGES.CHECKOUT_SESSION_SUPERSEDED;
-        const summaryMessage = String(summary?.message || '').trim();
-        if (summaryMessage)
-            return summaryMessage;
+        const message = resolveCommercialLifecyclePresentation(summary, gateState).message;
+        if (message)
+            return message;
         return String(fallback || 'Unable to confirm checkout completion.').trim() || 'Unable to confirm checkout completion.';
+    }, [gateState]);
+    const shouldAutoContinueAfterActivation = useCallback((summary, fallbackGate) => {
+        return !resolveCommercialLifecyclePresentation(summary, fallbackGate).allowReturnToApp;
     }, []);
-    const resolveGateFeedbackType = useCallback((message) => {
-        const normalized = String(message || '').trim();
-        if (normalized === GATE_MESSAGES.planSelectionRequired
-            || normalized === GATE_MESSAGES.checkoutPending) {
-            return 'info';
-        }
-        return 'error';
-    }, []);
-    const startCheckout = useCallback(async (planVersionId, interval) => {
+    const startCheckout = useCallback(async (planVersionId, interval, options) => {
         if (!planVersionId) {
             setFeedback({ type: 'error', message: 'Selected plan is missing a default plan version.' });
             return;
         }
-        const hadActiveEntitlement = hasResolvedActiveEntitlement;
         setActionBusy(true);
         setFeedback(null);
         try {
@@ -201,7 +165,7 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
                 invalidateAccountProfileSummaryCache(buildCloudBillingUrl(ACCOUNT_PROFILE_SUMMARY_PATH), { identityKey: authUserId });
                 const summary = await loadAccountProfileSummary({ force: true });
                 const summaryState = String(summary?.entitlementState || '').trim().toLowerCase();
-                if (!hadActiveEntitlement && ACTIVE_ENTITLEMENT_STATES.has(summaryState)) {
+                if (options?.autoContinueOnActivation === true && isCommercialEntitlementActive(summaryState)) {
                     await onContinueToTaskforce?.();
                 }
                 return;
@@ -211,7 +175,7 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
                 invalidateAccountProfileSummaryCache(buildCloudBillingUrl(ACCOUNT_PROFILE_SUMMARY_PATH), { identityKey: authUserId });
                 const summary = await loadAccountProfileSummary({ force: true });
                 const summaryState = String(summary?.entitlementState || '').trim().toLowerCase();
-                if (!hadActiveEntitlement && ACTIVE_ENTITLEMENT_STATES.has(summaryState)) {
+                if (options?.autoContinueOnActivation === true && isCommercialEntitlementActive(summaryState)) {
                     await onContinueToTaskforce?.();
                 }
                 return;
@@ -253,12 +217,13 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
         finally {
             setActionBusy(false);
         }
-    }, [authUserId, buildCloudBillingUrl, hasResolvedActiveEntitlement, loadAccountProfileSummary, onContinueToTaskforce, runtimeMode]);
-    const confirmCheckoutSession = useCallback(async (sessionId) => {
+    }, [authUserId, buildCloudBillingUrl, loadAccountProfileSummary, onContinueToTaskforce, runtimeMode]);
+    const confirmCheckoutSession = useCallback(async (sessionId, options) => {
         if (!sessionId) {
             return {
                 confirmed: false,
-                errorMessage: 'Checkout session is missing.'
+                errorMessage: 'Checkout session is missing.',
+                retryable: false
             };
         }
         try {
@@ -270,15 +235,17 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
             });
             const payload = await res.json().catch(() => ({}));
             if (!res.ok) {
+                const errorCode = String(payload?.code || '').trim();
                 return {
                     confirmed: false,
-                    errorMessage: String(payload?.error || 'Unable to confirm checkout completion.')
+                    errorMessage: String(payload?.error || 'Unable to confirm checkout completion.'),
+                    retryable: shouldRetryCheckoutConfirmation(res.status, errorCode)
                 };
             }
             invalidateAccountProfileSummaryCache(buildCloudBillingUrl(ACCOUNT_PROFILE_SUMMARY_PATH), { identityKey: authUserId });
             const summary = await loadAccountProfileSummary({ force: true });
             const summaryState = String(summary?.entitlementState || '').trim().toLowerCase();
-            if (ACTIVE_ENTITLEMENT_STATES.has(summaryState)) {
+            if (options?.autoContinueOnActivation === true && isCommercialEntitlementActive(summaryState)) {
                 await onContinueToTaskforce?.();
             }
             return { confirmed: true };
@@ -286,7 +253,8 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
         catch {
             return {
                 confirmed: false,
-                errorMessage: 'Unable to confirm checkout completion.'
+                errorMessage: 'Unable to confirm checkout completion.',
+                retryable: true
             };
         }
     }, [authUserId, buildCloudBillingUrl, loadAccountProfileSummary, onContinueToTaskforce]);
@@ -337,15 +305,84 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
         }
     }, []);
     useEffect(() => {
+        if (checkoutState !== 'success') {
+            checkoutSuccessHandledRef.current = null;
+        }
+    }, [checkoutState]);
+    useEffect(() => {
+        let cancelled = false;
+        const pendingRetryTimeouts = new Set();
+        const waitForRetry = async (delayMs) => {
+            if (delayMs <= 0)
+                return;
+            await new Promise((resolve) => {
+                const timeoutId = window.setTimeout(() => {
+                    pendingRetryTimeouts.delete(timeoutId);
+                    resolve();
+                }, delayMs);
+                pendingRetryTimeouts.add(timeoutId);
+            });
+        };
         if (checkoutState === 'success') {
             checkoutStartRan.current = true;
             setFeedback({ type: 'success', message: 'Checkout completed successfully. Finalizing your plan...' });
+            if (!authSessionResolved) {
+                return () => {
+                    cancelled = true;
+                    pendingRetryTimeouts.forEach((timeoutId) => window.clearTimeout(timeoutId));
+                    pendingRetryTimeouts.clear();
+                };
+            }
+            if (!isAuthenticated) {
+                setFeedback({ type: 'error', message: 'Sign in to finish activating your plan.' });
+                return () => {
+                    cancelled = true;
+                    pendingRetryTimeouts.forEach((timeoutId) => window.clearTimeout(timeoutId));
+                    pendingRetryTimeouts.clear();
+                };
+            }
+            const successFlowKey = querySessionId || '__missing_session__';
+            if (checkoutSuccessHandledRef.current === successFlowKey) {
+                return () => {
+                    cancelled = true;
+                    pendingRetryTimeouts.forEach((timeoutId) => window.clearTimeout(timeoutId));
+                    pendingRetryTimeouts.clear();
+                };
+            }
+            checkoutSuccessHandledRef.current = successFlowKey;
             void (async () => {
-                const confirmation = querySessionId
-                    ? await confirmCheckoutSession(querySessionId)
-                    : { confirmed: false, errorMessage: 'Checkout session is missing.' };
+                const preConfirmationSummary = await loadAccountProfileSummary({ force: true });
+                if (cancelled)
+                    return;
+                let confirmation = querySessionId
+                    ? { confirmed: false, errorMessage: 'Unable to confirm checkout completion.', retryable: true }
+                    : { confirmed: false, errorMessage: 'Checkout session is missing.', retryable: false };
+                for (const delayMs of CHECKOUT_CONFIRM_RETRY_DELAYS_MS) {
+                    await waitForRetry(delayMs);
+                    if (cancelled)
+                        return;
+                    confirmation = querySessionId
+                        ? await confirmCheckoutSession(querySessionId, {
+                            autoContinueOnActivation: shouldAutoContinueAfterActivation(preConfirmationSummary, gateState)
+                        })
+                        : { confirmed: false, errorMessage: 'Checkout session is missing.', retryable: false };
+                    if (cancelled)
+                        return;
+                    if (confirmation.confirmed) {
+                        setFeedback({ type: 'success', message: 'Checkout completed successfully.' });
+                        scheduleTransientQueryClear();
+                        return;
+                    }
+                    if (!confirmation.retryable) {
+                        break;
+                    }
+                }
+                if (cancelled)
+                    return;
                 if (!confirmation.confirmed) {
                     const summary = await loadAccountProfileSummary({ force: true });
+                    if (cancelled)
+                        return;
                     setFeedback({
                         type: 'error',
                         message: resolveRecoveryMessage(summary, confirmation.errorMessage)
@@ -353,10 +390,12 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
                     scheduleTransientQueryClear();
                     return;
                 }
-                setFeedback({ type: 'success', message: 'Checkout completed successfully.' });
-                scheduleTransientQueryClear();
             })();
-            return;
+            return () => {
+                cancelled = true;
+                pendingRetryTimeouts.forEach((timeoutId) => window.clearTimeout(timeoutId));
+                pendingRetryTimeouts.clear();
+            };
         }
         if (checkoutState === 'cancel') {
             void (async () => {
@@ -371,29 +410,31 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
         }
         if ((checkoutState === 'start' || checkoutState === 'free') && isAuthenticated && queryPlanVersionId && !checkoutStartRan.current) {
             checkoutStartRan.current = true;
-            void startCheckout(queryPlanVersionId, queryInterval);
+            void (async () => {
+                const preCheckoutSummary = await loadAccountProfileSummary({ force: true });
+                await startCheckout(queryPlanVersionId, queryInterval, {
+                    autoContinueOnActivation: shouldAutoContinueAfterActivation(preCheckoutSummary, gateState)
+                });
+            })();
+            return;
+        }
+    }, [authSessionResolved, checkoutState, confirmCheckoutSession, gateState, isAuthenticated, loadAccountProfileSummary, queryInterval, queryPlanVersionId, querySessionId, resolveRecoveryMessage, scheduleTransientQueryClear, shouldAutoContinueAfterActivation, startCheckout]);
+    useEffect(() => {
+        if (checkoutState === 'success' || checkoutState === 'cancel' || checkoutState === 'start' || checkoutState === 'free') {
             return;
         }
         if (gateMessage) {
-            setFeedback({ type: resolveGateFeedbackType(gateMessage), message: gateMessage });
+            setFeedback({ type: lifecyclePresentation.statusTone, message: gateMessage });
             return;
         }
         setFeedback((current) => {
             if (!current || current.type !== 'error')
                 return current;
-            if (current.message === GATE_MESSAGES.planSelectionRequired)
-                return null;
-            if (current.message === GATE_MESSAGES.misconfigured)
-                return null;
-            if (current.message === GATE_MESSAGES.missingEntitlement)
-                return null;
-            if (current.message === BILLING_CONFLICT_MESSAGES.CHECKOUT_SESSION_EXPIRED)
-                return null;
-            if (current.message === BILLING_CONFLICT_MESSAGES.CHECKOUT_SESSION_SUPERSEDED)
+            if (current.message === lifecyclePresentation.message)
                 return null;
             return current;
         });
-    }, [checkoutState, confirmCheckoutSession, gateMessage, isAuthenticated, loadAccountProfileSummary, queryInterval, queryPlanVersionId, querySessionId, resolveGateFeedbackType, resolveRecoveryMessage, scheduleTransientQueryClear, startCheckout]);
+    }, [checkoutState, gateMessage, lifecyclePresentation.message, lifecyclePresentation.statusTone]);
     const handleSelectPlan = useCallback(async (intent) => {
         if (!isAuthenticated) {
             const nextCheckoutState = intent.pricingType === 'free' ? 'free' : 'start';
@@ -414,12 +455,13 @@ export function PlansPage({ isAuthenticated, authUserId, runtimeMode, authSessio
             await openBillingPortal();
             return;
         }
+        const autoContinueOnActivation = shouldAutoContinueAfterActivation(accountProfileSummary, gateState);
         if (intent.pricingType === 'free') {
-            await startCheckout(intent.planVersionId, intent.interval);
+            await startCheckout(intent.planVersionId, intent.interval, { autoContinueOnActivation });
             return;
         }
-        await startCheckout(intent.planVersionId, intent.interval);
-    }, [isAuthenticated, navigate, openBillingPortal, startCheckout]);
+        await startCheckout(intent.planVersionId, intent.interval, { autoContinueOnActivation });
+    }, [accountProfileSummary, gateState, isAuthenticated, navigate, openBillingPortal, shouldAutoContinueAfterActivation, startCheckout]);
     const handleBack = useCallback(() => {
         if (hasResolvedActiveEntitlement && onContinueToTaskforce) {
             void onContinueToTaskforce();