fix(admin): count former actors' runs once, not once per actor

Former actors' workflow runs were the sum of their per-user counts, so a run
shared by two former actors counted twice. Group the same scan by a
former-actor flag as well and read the distinct count from it. The flag
tests membership against two uncorrelated lists, so each is hashed once.

Also drop the last non-null assertion in the organizations list and shrink
the explicit-any baseline.

Author: waleedlatif1

apps/sim/lib/admin/dashboard-usage.integration.ts

@@ -13,7 +13,7 @@ import {
   readDashboardHistoricalActorSpend,
   readDashboardLedgerSpend,
   readDashboardLedgerSpendByUser,
-  readDashboardWorkflowRuns,
+  readDashboardOrganizationWorkflowRuns,
 } from '@/lib/admin/dashboard-usage'
 import type { ResolvedUsagePeriod } from '@/lib/billing/core/reporting-period'
 
@@ -86,6 +86,9 @@ beforeAll(async () => {
       ('u3', 'model', 'copilot', 0.1, 'organization', 'org-a', ${P}, NULL, '2026-08-07'),
       ('u4', 'model', 'copilot', 0.2, 'organization', 'org-a', ${P}, NULL, '2026-08-07'),
       ('u5', 'model', 'workflow', 0.3, 'organization', 'org-a', ${P}, 'e11', '2026-08-07'),
+      -- one run shared by two former actors
+      ('u3', 'model', 'workflow', 0.1, 'organization', 'org-a', ${P}, 'e12', '2026-08-08'),
+      ('u5', 'model', 'workflow', 0.1, 'organization', 'org-a', ${P}, 'e12', '2026-08-08'),
 
       -- org-b, reporting period: matched on created_at, start inclusive and end exclusive,
       -- whatever the rows are stamped with.
@@ -119,15 +122,15 @@ describe('dashboard ledger usage', () => {
       { entity: { type: 'user', id: 'p1' }, period: stampedPeriod },
     ])
 
-    expect(Object.fromEntries(spend)).toEqual({ 'org-a': 3.38, 'org-b': 1.75, p1: 0.6 })
+    expect(Object.fromEntries(spend)).toEqual({ 'org-a': 3.58, 'org-b': 1.75, p1: 0.6 })
   })
 
   it('reads an entity once however many times it is asked for', async () => {
     const spend = await readDashboardLedgerSpend([
       organizationWindow('org-a', stampedPeriod),
       organizationWindow('org-a', stampedPeriod),
     ])
-    expect(spend.get('org-a')).toBe(3.38)
+    expect(spend.get('org-a')).toBe(3.58)
   })
 
   it('splits spend by acting user', async () => {
@@ -139,9 +142,9 @@ describe('dashboard ledger usage', () => {
     expect(Object.fromEntries(spend.get('org-a') ?? [])).toEqual({
       u1: 1.51,
       u2: 0.37,
-      u3: 1,
+      u3: 1.1,
       u4: 0.2,
-      u5: 0.3,
+      u5: 0.4,
     })
     expect(Object.fromEntries(spend.get('org-b') ?? [])).toEqual({ u6: 1.75 })
   })
@@ -154,18 +157,21 @@ describe('dashboard ledger usage', () => {
     expect((await readDashboardLedgerSpendByUser([window], [])).size).toBe(0)
   })
 
-  it('counts distinct workflow runs in total and for each actor of a shared run', async () => {
-    const orgA = await readDashboardWorkflowRuns(organizationWindow('org-a', stampedPeriod))
-    expect(orgA?.total).toBe(5)
-    expect(Object.fromEntries(orgA?.byUser ?? [])).toEqual({ u1: 2, u2: 2, u3: 1, u5: 1 })
+  it('counts distinct workflow runs in total, for each actor of a shared run, and once across former actors', async () => {
+    const orgA = await readDashboardOrganizationWorkflowRuns('org-a', stampedPeriod)
+    expect(orgA?.total).toBe(6)
+    expect(Object.fromEntries(orgA?.byUser ?? [])).toEqual({ u1: 2, u2: 2, u3: 2, u5: 2 })
+    expect(orgA?.formerActors).toBe(3)
 
-    const orgB = await readDashboardWorkflowRuns(organizationWindow('org-b', reportingPeriod))
+    const orgB = await readDashboardOrganizationWorkflowRuns('org-b', reportingPeriod)
     expect(orgB?.total).toBe(3)
     expect(Object.fromEntries(orgB?.byUser ?? [])).toEqual({ u6: 3 })
+    expect(orgB?.formerActors).toBe(3)
 
-    const empty = await readDashboardWorkflowRuns(organizationWindow('org-c', stampedPeriod))
+    const empty = await readDashboardOrganizationWorkflowRuns('org-c', stampedPeriod)
     expect(empty?.total).toBe(0)
     expect(empty?.byUser.size).toBe(0)
+    expect(empty?.formerActors).toBe(0)
   })
 
   it('reports runs as unknown when the count outlasts its budget', async () => {
@@ -190,7 +196,7 @@ describe('dashboard ledger usage', () => {
     })
     try {
       await locked
-      expect(await readDashboardWorkflowRuns(organizationWindow('org-a', stampedPeriod))).toBeNull()
+      expect(await readDashboardOrganizationWorkflowRuns('org-a', stampedPeriod)).toBeNull()
     } finally {
       release()
       await holder
@@ -200,6 +206,6 @@ describe('dashboard ledger usage', () => {
 
   it('spends only for actors who are neither members nor collaborators of the organization', async () => {
     const spend = await readDashboardHistoricalActorSpend('org-a', stampedPeriod)
-    expect(Object.fromEntries(spend)).toEqual({ u3: 1, u4: 0.2, u5: 0.3 })
+    expect(Object.fromEntries(spend)).toEqual({ u3: 1.1, u4: 0.2, u5: 0.4 })
   })
 })

apps/sim/lib/admin/dashboard-usage.ts

@@ -2,8 +2,8 @@ import { db } from '@sim/db'
 import { member, permissions, usageLog, workspace } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { getPostgresCancellationReason } from '@sim/utils/errors'
-import { and, countDistinct, eq, inArray, notExists, type SQL, sql } from 'drizzle-orm'
-import { alias, unionAll } from 'drizzle-orm/pg-core'
+import { and, countDistinct, eq, inArray, notInArray, type SQL, sql } from 'drizzle-orm'
+import { unionAll } from 'drizzle-orm/pg-core'
 import { readLedgerBounded } from '@/lib/billing/core/ledger-read'
 import type { ResolvedUsagePeriod } from '@/lib/billing/core/reporting-period'
 import { buildUsageAnalyticsScope } from '@/lib/billing/core/usage-analytics'
@@ -50,6 +50,8 @@ interface DashboardWorkflowRuns {
   total: number
   /** Runs per acting user; a run with rows from two actors counts for each. */
   byUser: Map<string, number>
+  /** Distinct runs across the organization's former actors together. */
+  formerActors: number
 }
 
 /**
@@ -139,25 +141,58 @@ export async function readDashboardLedgerSpendByUser(
 }
 
 /**
- * One entity's workflow runs over its period, in total and per acting user, from one
- * scan. `null` when the count does not finish within {@link WORKFLOW_RUNS_BUDGET_MS}.
+ * Who no longer represents an organization's usage: an actor who is neither a member nor a
+ * collaborator on one of its workspaces any more. Uncorrelated, so each list is hashed once
+ * rather than probed for every ledger row.
  */
-export async function readDashboardWorkflowRuns(
-  window: DashboardLedgerWindow
+function isFormerActor(organizationId: string): SQL {
+  const members = db
+    .select({ userId: member.userId })
+    .from(member)
+    .where(eq(member.organizationId, organizationId))
+  const collaborators = db
+    .select({ userId: permissions.userId })
+    .from(permissions)
+    .innerJoin(
+      workspace,
+      and(eq(permissions.entityType, 'workspace'), eq(permissions.entityId, workspace.id))
+    )
+    .where(eq(workspace.organizationId, organizationId))
+  return sql`(${notInArray(usageLog.userId, members)} and ${notInArray(usageLog.userId, collaborators)})`
+}
+
+/**
+ * An organization's workflow runs over its period, in total, per acting user and across its
+ * former actors, from one scan. `null` when the count does not finish within
+ * {@link WORKFLOW_RUNS_BUDGET_MS}.
+ */
+export async function readDashboardOrganizationWorkflowRuns(
+  organizationId: string,
+  period: ResolvedUsagePeriod
 ): Promise<DashboardWorkflowRuns | null> {
-  let rows: { userId: string | null; workflowRuns: number }[]
+  let rows: { userId: string | null; formerActor: boolean | null; workflowRuns: number }[]
   try {
     rows = await readLedgerBounded(
       db,
-      (tx) =>
-        tx
+      (tx) => {
+        const workflowRows = tx
           .select({
-            userId: sql<string | null>`${usageLog.userId}`,
-            workflowRuns: countDistinct(usageLog.executionId),
+            userId: usageLog.userId,
+            executionId: usageLog.executionId,
+            formerActor: sql<boolean>`${isFormerActor(organizationId)}`.as('former_actor'),
           })
           .from(usageLog)
-          .where(and(...windowScope(window), WORKFLOW_SOURCE))
-          .groupBy(sql`grouping sets ((${usageLog.userId}), ())`),
+          .where(and(...windowScope(organizationWindow(organizationId, period)), WORKFLOW_SOURCE))
+          .as('workflow_rows')
+        return tx
+          .select({
+            userId: sql<string | null>`${workflowRows.userId}`,
+            formerActor: sql<boolean | null>`${workflowRows.formerActor}`,
+            workflowRuns: countDistinct(workflowRows.executionId),
+          })
+          .from(workflowRows)
+          .groupBy(sql`grouping sets ((${workflowRows.userId}), (${workflowRows.formerActor}), ())`)
+      },
       WORKFLOW_RUNS_BUDGET_MS
     )
   } catch (error) {
@@ -166,71 +201,34 @@ export async function readDashboardWorkflowRuns(
       getPostgresCancellationReason(error) === 'statement_timeout'
     if (!overBudget) throw error
     logger.warn('Workflow run count exceeded its budget', {
-      entityType: window.entity.type,
-      entityId: window.entity.id,
+      organizationId,
       budgetMs: WORKFLOW_RUNS_BUDGET_MS,
     })
     return null
   }
 
-  const runs: DashboardWorkflowRuns = { total: 0, byUser: new Map() }
+  const runs: DashboardWorkflowRuns = { total: 0, byUser: new Map(), formerActors: 0 }
   for (const row of rows) {
-    if (row.userId === null) runs.total = row.workflowRuns
-    else runs.byUser.set(row.userId, row.workflowRuns)
+    if (row.userId !== null) runs.byUser.set(row.userId, row.workflowRuns)
+    else if (row.formerActor === null) runs.total = row.workflowRuns
+    else if (row.formerActor) runs.formerActors = row.workflowRuns
   }
   return runs
 }
 
-const historicalUsageMember = alias(member, 'historical_usage_member')
-const historicalUsagePermission = alias(permissions, 'historical_usage_permission')
-const historicalUsageWorkspace = alias(workspace, 'historical_usage_workspace')
-
-/**
- * An organization's period spend per actor who is neither a member nor a collaborator on
- * one of its workspaces any more.
- */
+/** An organization's period spend per former actor (see {@link isFormerActor}). */
 export async function readDashboardHistoricalActorSpend(
   organizationId: string,
   period: ResolvedUsagePeriod
 ): Promise<Map<string, number>> {
-  const currentMember = db
-    .select({ value: sql`1` })
-    .from(historicalUsageMember)
-    .where(
-      and(
-        eq(historicalUsageMember.organizationId, organizationId),
-        eq(historicalUsageMember.userId, usageLog.userId)
-      )
-    )
-  const currentCollaborator = db
-    .select({ value: sql`1` })
-    .from(historicalUsagePermission)
-    .innerJoin(
-      historicalUsageWorkspace,
-      and(
-        eq(historicalUsagePermission.entityType, 'workspace'),
-        eq(historicalUsagePermission.entityId, historicalUsageWorkspace.id)
-      )
-    )
-    .where(
-      and(
-        eq(historicalUsageWorkspace.organizationId, organizationId),
-        eq(historicalUsagePermission.userId, usageLog.userId)
-      )
-    )
-
   const rows = await db
     .select({
       userId: usageLog.userId,
       cost: sql<string>`coalesce(sum(${usageLog.cost}), 0)`,
     })
     .from(usageLog)
     .where(
-      and(
-        ...windowScope(organizationWindow(organizationId, period)),
-        notExists(currentMember),
-        notExists(currentCollaborator)
-      )
+      and(...windowScope(organizationWindow(organizationId, period)), isFormerActor(organizationId))
     )
     .groupBy(usageLog.userId)
   return new Map(rows.map((row) => [row.userId, Number(row.cost)]))

apps/sim/lib/admin/dashboard.ts

@@ -19,7 +19,7 @@ import {
   readDashboardHistoricalActorSpend,
   readDashboardLedgerSpend,
   readDashboardLedgerSpendByUser,
-  readDashboardWorkflowRuns,
+  readDashboardOrganizationWorkflowRuns,
 } from '@/lib/admin/dashboard-usage'
 import {
   getOrganizationUsageLimitFallbackDollars,
@@ -564,21 +564,14 @@ export async function listDashboardOrganizations({ search, limit, offset }: Pagi
     )
   )
   const subscriptionByOrganization = new Map(subscriptionRows.map((row) => [row.referenceId, row]))
-  const usagePeriodsByOrganization = new Map(
-    organizationIds.map(
-      (organizationId) =>
-        [
-          organizationId,
-          resolveDashboardUsagePeriod(subscriptionByOrganization.get(organizationId) ?? null),
-        ] as const
-    )
-  )
+  const organizations = orgRows.map((org) => {
+    const latestSubscription = subscriptionByOrganization.get(org.id) ?? null
+    return { org, latestSubscription, usagePeriod: resolveDashboardUsagePeriod(latestSubscription) }
+  })
   const spendByOrganization = await readDashboardLedgerSpend(
-    [...usagePeriodsByOrganization].map(([organizationId, period]) =>
-      organizationWindow(organizationId, period)
-    )
+    organizations.map(({ org, usagePeriod }) => organizationWindow(org.id, usagePeriod))
   )
-  const data = orgRows.map((org) => {
+  const data = organizations.map(({ org, latestSubscription, usagePeriod }) => {
     const membership = membershipsByOrganization.get(org.id)
     const owner =
       membership?.ownerId && membership.ownerName && membership.ownerEmail
@@ -592,12 +585,12 @@ export async function listDashboardOrganizations({ search, limit, offset }: Pagi
       org,
       memberCount: membership?.memberCount ?? 0,
       externalCollaboratorCount: externalCountByOrganization.get(org.id) ?? 0,
-      latestSubscription: subscriptionByOrganization.get(org.id) ?? null,
+      latestSubscription,
       provisioning: provisionings.get(org.id) ?? null,
       owner,
       usageDollars: spendByOrganization.get(org.id) ?? 0,
       workflowRuns: null,
-      usagePeriod: usagePeriodsByOrganization.get(org.id)!,
+      usagePeriod,
     })
     return summary
   })
@@ -726,18 +719,15 @@ export async function getDashboardOrganization(
       historicalActorSpend,
     }
   }
-  const [workflowRuns, page] = await Promise.all([readDashboardWorkflowRuns(window), readPage()])
+  const [workflowRuns, page] = await Promise.all([
+    readDashboardOrganizationWorkflowRuns(organizationId, usagePeriod),
+    readPage(),
+  ])
   const limits = new Map(page.limitRows.map((row) => [row.userId, Number(row.limit)]))
   const usageByUser = page.spendByOrganization.get(organizationId) ?? new Map<string, number>()
   const runsOf = (userId: string) => (workflowRuns ? (workflowRuns.byUser.get(userId) ?? 0) : null)
   let historicalUsedDollars = 0
   for (const cost of page.historicalActorSpend.values()) historicalUsedDollars += cost
-  let historicalWorkflowRuns: number | null = null
-  if (workflowRuns) {
-    historicalWorkflowRuns = 0
-    for (const userId of page.historicalActorSpend.keys())
-      historicalWorkflowRuns += runsOf(userId) ?? 0
-  }
   const workspaceTotal = page.workspaceCountRows[0]?.value ?? 0
   return {
     ...base,
@@ -749,7 +739,7 @@ export async function getDashboardOrganization(
     historicalActorUsage: {
       usedDollars: historicalUsedDollars,
       usedCredits: dollarsToCredits(historicalUsedDollars),
-      workflowRuns: historicalWorkflowRuns,
+      workflowRuns: workflowRuns?.formerActors ?? null,
       actorCount: page.historicalActorSpend.size,
     },
     members: page.memberRows.map((row) => ({

scripts/check-explicit-any.baseline.json

@@ -1353,7 +1353,6 @@
     "apps/sim/hooks/use-permission-config.test.tsx": 10,
     "apps/sim/hooks/use-permission-config.ts": 1,
     "apps/sim/hooks/use-voice-input.test.tsx": 1,
-    "apps/sim/lib/admin/dashboard.ts": 2,
     "apps/sim/lib/api/contracts/mothership-assistant-tools.test.ts": 2,
     "apps/sim/lib/api/contracts/mothership-management-tools.test.ts": 1,
     "apps/sim/lib/api/contracts/v2/tables.test.ts": 1,