fix(billing): bucket refresh by clamped day so stamped stragglers stay in the deduction

Refresh membership is now the entity/period stamps alone — identical to the
ledger sums it offsets. A row written after the rollover but stamped to the
elapsed period (attribution frozen at run start) is billed by the stamp-based
close, so it must consume refresh too; created-at now only assigns the day
bucket, clamped into the period, instead of excluding the row entirely.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: icecrasher321

apps/sim/lib/billing/credits/daily-refresh.test.ts

@@ -136,6 +136,28 @@ describe('computeDailyRefreshConsumed', () => {
     expect(drizzleOrmMock.inArray).not.toHaveBeenCalled()
   })
 
+  it('keeps straggler rows stamped to the period but written after its end', async () => {
+    // A run that started before the rollover inserts rows stamped with the
+    // elapsed period after it ended; the stamp-based close bills them, so the
+    // deduction must include them too (clamped into the final day bucket).
+    dbChainMockFns.groupBy.mockResolvedValueOnce([{ dayIndex: 30, dayTotal: '0.30' }])
+    const periodStart = new Date('2026-03-01')
+    const periodEnd = new Date('2026-04-01')
+
+    const result = await computeDailyRefreshConsumed({
+      billingEntity: { type: 'user', id: 'user-1' },
+      periodStart,
+      periodEnd,
+      planDollars: 25,
+    })
+
+    expect(result).toBe(0.25)
+    // Membership is stamp-only: no created-at bound may exclude a row the
+    // stamped ledger total includes.
+    expect(drizzleOrmMock.lt).not.toHaveBeenCalledWith(schemaMock.usageLog.createdAt, periodEnd)
+    expect(drizzleOrmMock.gte).not.toHaveBeenCalled()
+  })
+
   it('rejects windows beyond the supported annual bound', async () => {
     await expect(
       computeDailyRefreshConsumed({

apps/sim/lib/billing/credits/daily-refresh.ts

@@ -45,7 +45,9 @@ interface BillingPeriodUsageWithDailyRefreshParams {
  *
  * The two aggregates intentionally keep different predicates. Ledger totals
  * use both captured period bounds (or a reporting-time window), while refresh
- * uses the captured period start plus a created-at day window.
+ * membership is the captured period-start stamp alone — created-at only
+ * buckets rows into days, clamped into the period (see
+ * `computeDailyRefreshConsumed` for why).
  */
 export async function computeBillingPeriodUsageWithDailyRefresh(
   params: BillingPeriodUsageWithDailyRefreshParams,
@@ -64,11 +66,7 @@ export async function computeBillingPeriodUsageWithDailyRefresh(
   const dailyRefreshDollars = planDollars * DAILY_REFRESH_RATE * seats
   const refreshWindowActive = cap > refreshPeriodStart
   const refreshFilter = refreshWindowActive
-    ? and(
-        eq(usageLog.billingPeriodStart, refreshPeriodStart),
-        gte(usageLog.createdAt, refreshPeriodStart),
-        lt(usageLog.createdAt, cap)
-      )
+    ? eq(usageLog.billingPeriodStart, refreshPeriodStart)
     : sql<boolean>`false`
   const ledgerPeriodFilter =
     billingPeriod.source === 'reporting'
@@ -81,22 +79,18 @@ export async function computeBillingPeriodUsageWithDailyRefresh(
   const sameCapturedPeriodStart =
     billingPeriod.source !== 'reporting' &&
     billingPeriod.start.getTime() === refreshPeriodStart.getTime()
-  const reportingWindowContainsRefresh =
-    billingPeriod.source === 'reporting' &&
-    refreshPeriodStart >= billingPeriod.start &&
-    cap <= billingPeriod.end
   const scanFilter = !refreshWindowActive
     ? ledgerPeriodFilter
     : sameCapturedPeriodStart
       ? eq(usageLog.billingPeriodStart, billingPeriod.start)
-      : reportingWindowContainsRefresh
-        ? ledgerPeriodFilter
-        : or(ledgerPeriodFilter, refreshFilter)
+      : or(ledgerPeriodFilter, refreshFilter)
 
+  const startEpoch = Math.floor(refreshPeriodStart.getTime() / 1000)
+  const capEpoch = Math.floor(cap.getTime() / 1000)
   const rows = await executor
     .select({
       dayIndex:
-        sql<number>`FLOOR((EXTRACT(EPOCH FROM ${usageLog.createdAt}) - ${Math.floor(refreshPeriodStart.getTime() / 1000)}) / 86400)`.as(
+        sql<number>`FLOOR((LEAST(GREATEST(EXTRACT(EPOCH FROM ${usageLog.createdAt}), ${startEpoch}), ${capEpoch - 1}) - ${startEpoch}) / 86400)`.as(
           'day_index'
         ),
       ledgerTotal:
@@ -167,10 +161,17 @@ export async function computeDailyRefreshConsumed(
     throw new Error('Billing period exceeds the supported annual bound')
   }
 
+  // Membership mirrors the ledger sums exactly: the entity and period stamps
+  // alone. Created-at only assigns the day bucket, clamped into the period —
+  // a straggler row written after the rollover (billing attribution is frozen
+  // at run start) is billed by the stamp-based close, so it must consume
+  // refresh on the period's final day rather than fall out of the deduction.
+  const startEpoch = Math.floor(periodStart.getTime() / 1000)
+  const capEpoch = Math.floor(cap.getTime() / 1000)
   const rows = await executor
     .select({
       dayIndex:
-        sql<number>`FLOOR((EXTRACT(EPOCH FROM ${usageLog.createdAt}) - ${Math.floor(periodStart.getTime() / 1000)}) / 86400)`.as(
+        sql<number>`FLOOR((LEAST(GREATEST(EXTRACT(EPOCH FROM ${usageLog.createdAt}), ${startEpoch}), ${capEpoch - 1}) - ${startEpoch}) / 86400)`.as(
           'day_index'
         ),
       dayTotal: sum(usageLog.cost).as('day_total'),
@@ -180,9 +181,7 @@ export async function computeDailyRefreshConsumed(
       and(
         eq(usageLog.billingEntityType, billingEntity.type),
         eq(usageLog.billingEntityId, billingEntity.id),
-        eq(usageLog.billingPeriodStart, periodStart),
-        gte(usageLog.createdAt, periodStart),
-        lt(usageLog.createdAt, cap)
+        eq(usageLog.billingPeriodStart, periodStart)
       )
     )
     .groupBy(sql`day_index`)