fix(billing): reload an ended cached period, keep org payers org-scoped, keep blocked accounts blocked

Author: waleedlatif1

apps/sim/app/api/billing/update-cost/route.test.ts

@@ -1153,6 +1153,26 @@ describe('POST /api/billing/update-cost — mid-run usage gate', () => {
     expect(body.usageExceeded).toBe(false)
   })
 
+  it('reloads a cached current period once it has ended', async () => {
+    const ending = {
+      ...CURRENT_ATTRIBUTION,
+      billingPeriod: {
+        start: '2026-07-01T00:00:00.000Z',
+        end: new Date(Date.now() + 50).toISOString(),
+      },
+    }
+    mockRefreshAttributionPeriod
+      .mockResolvedValueOnce(ending)
+      .mockResolvedValue(CURRENT_ATTRIBUTION)
+    refuseOnlyCurrentPeriod()
+    await POST(attributedCallback())
+    await sleep(100)
+
+    const body = await (await POST(attributedCallback())).json()
+
+    expect(body.usageExceeded).toBe(true)
+  })
+
   it('never answers a verdict whose card and flag disagree', () => {
     const base = {
       success: true,

apps/sim/app/api/copilot/api-keys/validate/route.test.ts

@@ -796,6 +796,19 @@ describe('validation lifecycle purposes', () => {
     expect(response.status).toBe(402)
   })
 
+  it('judges a direct-v1 organization payer without a subscription as that organization', async () => {
+    mockGetOrganizationSubscription.mockResolvedValue(null)
+    mockCheckUsageStatus.mockImplementation(
+      async (_userId: string, subscription: { referenceId?: string } | null) => ({
+        isExceeded: subscription?.referenceId === 'account-org',
+        currentUsage: 12,
+        limit: 10,
+      })
+    )
+
+    expect((await POST(request(body, directHeaders))).status).toBe(402)
+  })
+
   it('refuses a blocked new turn with the blocked body the contract declares', async () => {
     mockCheckAttributedUsageLimits.mockResolvedValueOnce({
       isExceeded: true,

apps/sim/lib/billing/calculations/usage-monitor.test.ts

@@ -230,6 +230,19 @@ describe('checkServerSideUsageLimits', () => {
     expect(result.message ?? '').not.toMatch(/\$/)
   })
 
+  it('keeps a blocked account blocked when its ledger cannot be read', async () => {
+    dbChainMockFns.limit.mockResolvedValueOnce([{ blocked: true, blockedReason: 'dispute' }])
+    mockGetBillingPeriodUsageCost.mockRejectedValueOnce(new Error('canceling statement'))
+
+    const result = await checkServerSideUsageLimits('user-1', null)
+
+    expect(result).toMatchObject({
+      isExceeded: true,
+      reason: 'billing_blocked',
+      message: 'Account frozen. Please contact support to resolve this issue.',
+    })
+  })
+
   it('keeps blocked accounts blocked while reporting their real ledger usage', async () => {
     dbChainMockFns.limit.mockResolvedValueOnce([{ blocked: true, blockedReason: 'payment_failed' }])
     const subscription = {

apps/sim/lib/billing/calculations/usage-monitor.ts

@@ -1,7 +1,7 @@
 import { db } from '@sim/db'
 import { userStats } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { toError } from '@sim/utils/errors'
+import { getErrorMessage, toError } from '@sim/utils/errors'
 import { eq } from 'drizzle-orm'
 import { USAGE_UNAVAILABLE_MESSAGE } from '@/lib/billing/constants'
 import { isOrganizationBillingBlocked } from '@/lib/billing/core/access'
@@ -306,6 +306,38 @@ export async function checkBillingEntityBlocked(
  * @param userId The ID of the user to check
  * @returns An object containing the exceeded status and usage details
  */
+/**
+ * A blocked account's ledger usage, for display only: `/api/users/me/usage-limits` exposes it as
+ * `currentPeriodCost`. The account is blocked either way, so a failed read reports zero rather
+ * than turning the blocked refusal into an unreadable-usage one.
+ */
+async function readBlockedAccountUsage(
+  userId: string,
+  preloadedSubscription: UsageLimitSubscription | null | undefined,
+  preloadedBillingContext: BillingContext | undefined
+): Promise<number> {
+  try {
+    const sub =
+      preloadedSubscription !== undefined
+        ? preloadedSubscription
+        : await getHighestPrioritySubscription(userId)
+    const subIsOrgScoped = isOrgScopedSubscription(sub, userId)
+    const billingEntity: BillingEntity =
+      subIsOrgScoped && sub
+        ? { type: 'organization', id: sub.referenceId }
+        : { type: 'user', id: userId }
+    const billingPeriod = preloadedBillingContext?.billingPeriod ??
+      resolveSubscriptionUsagePeriod(sub) ?? { ...defaultBillingPeriod(), source: 'default' }
+    return await getBillingPeriodUsageCost(billingEntity, billingPeriod)
+  } catch (error) {
+    logger.warn('Blocked account usage could not be read', {
+      userId,
+      error: getErrorMessage(error),
+    })
+    return 0
+  }
+}
+
 export async function checkServerSideUsageLimits(
   userId: string,
   preloadedSubscription?: UsageLimitSubscription | null,
@@ -331,20 +363,11 @@ export async function checkServerSideUsageLimits(
 
     const blocked = await checkBillingBlocked(userId)
     if (blocked.blocked) {
-      // Enforcement stays blocked, but surfaced usage must be the real ledger
-      // value — `/api/users/me/usage-limits` exposes it as `currentPeriodCost`.
-      const sub =
-        preloadedSubscription !== undefined
-          ? preloadedSubscription
-          : await getHighestPrioritySubscription(userId)
-      const subIsOrgScoped = isOrgScopedSubscription(sub, userId)
-      const billingEntity: BillingEntity =
-        subIsOrgScoped && sub
-          ? { type: 'organization', id: sub.referenceId }
-          : { type: 'user', id: userId }
-      const billingPeriod = preloadedBillingContext?.billingPeriod ??
-        resolveSubscriptionUsagePeriod(sub) ?? { ...defaultBillingPeriod(), source: 'default' }
-      const currentUsage = await getBillingPeriodUsageCost(billingEntity, billingPeriod)
+      const currentUsage = await readBlockedAccountUsage(
+        userId,
+        preloadedSubscription,
+        preloadedBillingContext
+      )
       return {
         isExceeded: true,
         currentUsage,

apps/sim/lib/billing/core/mid-run-usage.ts

@@ -60,7 +60,8 @@ async function currentAttribution(
 ): Promise<BillingAttributionSnapshot> {
   const key = currentPeriodKey(attribution)
   const cached = fresh ? undefined : currentPeriodCache.get(key)
-  if (cached) return cached
+  // A cached period that has since ended is stale: the payer may already be in the next one.
+  if (cached && !periodHasEnded(cached)) return cached
   const current = await refreshAttributionPeriod(attribution)
   currentPeriodCache.set(key, current)
   return current
@@ -138,7 +139,21 @@ export async function readMidRunAccountUsageVerdict(
       ...defaultBillingPeriod(),
       source: 'default' as const,
     }
-    const usage = await checkUsageStatus(decision.userId, subscription, {
+    // An organization payer without a subscription stays organization-scoped on the free plan,
+    // as `toUsageLimitSubscription` does for attributed runs, never the actor's personal ledger.
+    const usageSubscription =
+      subscription ??
+      (payer.type === 'organization'
+        ? {
+            referenceId: payer.id,
+            plan: 'free',
+            status: null,
+            seats: null,
+            periodStart: billingPeriod.start,
+            periodEnd: billingPeriod.end,
+          }
+        : null)
+    const usage = await checkUsageStatus(decision.userId, usageSubscription, {
       billingEntity: payer,
       billingPeriod,
     })