fix(billing): drop the unreachable card-read deadline from the usage upgrade card

Every exceeded verdict that reaches update-cost now carries its payer, so the
deadline-bounded actor subscription lookup could no longer run. Remove the
parameter, its call-site argument, the stale TSDoc, and the test that passed
without exercising it.

Author: waleedlatif1

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

@@ -1073,23 +1073,6 @@ describe('POST /api/billing/update-cost — mid-run usage gate', () => {
 
       expect(body.usageExceeded).toBe(false)
     })
-
-    it('keeps the exceeded verdict with the plan-upgrade card when the card read outlasts the callback budget', async () => {
-      billingPlanMockFns.mockGetHighestPrioritySubscription.mockImplementation(async () => {
-        await sleep(1500)
-        return { plan: 'pro' }
-      })
-      const startedAt = Date.now()
-
-      const body = await (await POST(directCallback())).json()
-
-      expect(body).toMatchObject({
-        success: true,
-        usageExceeded: true,
-        usageUpgrade: { action: 'upgrade_plan' },
-      })
-      expect(Date.now() - startedAt).toBeLessThan(1400)
-    })
   })
 
   describe('a run that outlives its billing period', () => {

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

@@ -86,7 +86,7 @@ function invalidBillingProtocolResponse(requestId: string, span: Span): NextResp
  * already recorded when this runs; a gate that cannot answer reports not-exceeded and leaves the
  * refusal to the next step or re-check rather than ending a paying run on a database blip,
  * and so does a verdict read that outlasts {@link USAGE_STANDING_TIMEOUT_MS}. An exceeded
- * verdict always pauses the run; a card read past that budget falls back to the plan-upgrade card.
+ * verdict always pauses the run.
  */
 async function readUsageStanding(
   userId: string,
@@ -99,10 +99,9 @@ async function readUsageStanding(
       ? () => readMidRunAccountUsageVerdict(accountDecision)
       : null
   if (!isHosted || !readVerdict) return { usageExceeded: false }
-  const deadlineAt = Date.now() + USAGE_STANDING_TIMEOUT_MS
   let verdict: MidRunUsageVerdict
   try {
-    verdict = await withinDeadline(readVerdict, deadlineAt)
+    verdict = await withinDeadline(readVerdict, Date.now() + USAGE_STANDING_TIMEOUT_MS)
   } catch {
     logger.warn('Usage standing read outlasted the callback budget; answering not exceeded')
     return { usageExceeded: false }
@@ -115,8 +114,7 @@ async function readUsageStanding(
     usageUpgrade: await resolveUsageUpgradePayload(
       userId,
       billingAttribution ?? verdict.payer,
-      verdict.scope,
-      deadlineAt
+      verdict.scope
     ),
   }
 }

apps/sim/lib/billing/usage-upgrade.ts

@@ -6,7 +6,6 @@ import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
 import type { BillingEntity } from '@/lib/billing/core/usage-log'
 import { isEnterprise, isPaid } from '@/lib/billing/plan-helpers'
 import { isOrgScopedSubscription } from '@/lib/billing/subscriptions/utils'
-import { withinDeadline } from '@/lib/core/utils/deadline'
 
 const logger = createLogger('UsageUpgrade')
 
@@ -30,13 +29,12 @@ export interface UsageUpgradePayer {
  * increase for a paid one, with copy naming who can raise an organization's limit. A member
  * over the cap their organization set gets copy naming who can raise that cap. A known payer
  * decides the card without a query; otherwise the actor's current subscription decides, and a
- * lookup that fails or outlasts `deadlineAt` falls back to the plan-upgrade card.
+ * lookup that fails falls back to the plan-upgrade card.
  */
 export async function resolveUsageUpgradePayload(
   userId: string,
   payer?: UsageUpgradePayer,
-  scope?: AttributedUsageLimitsResult['scope'],
-  deadlineAt?: number
+  scope?: AttributedUsageLimitsResult['scope']
 ): Promise<UsageUpgradePayload> {
   if (scope === 'member') {
     return { reason: 'usage_limit', action: 'increase_limit', message: MEMBER_CAP_MESSAGE }
@@ -48,9 +46,7 @@ export async function resolveUsageUpgradePayload(
       plan = payer.payerSubscription?.plan
       orgScoped = payer.billingEntity.type === 'organization'
     } else {
-      const subscription = await (deadlineAt === undefined
-        ? getHighestPrioritySubscription(userId)
-        : withinDeadline(() => getHighestPrioritySubscription(userId), deadlineAt))
+      const subscription = await getHighestPrioritySubscription(userId)
       plan = subscription?.plan
       orgScoped = isOrgScopedSubscription(subscription, userId)
     }