From b459668009833f118cd202c8d28c75b5ea63e816 Mon Sep 17 00:00:00 2001
From: Forgotten <forgottenrunes@protonmail.com>
Date: Fri, 20 Feb 2026 13:47:21 -0600
Subject: [PATCH] fix: derive costs by-project from run usage instead of cost
 events

Joins heartbeat runs to issues via activity log to attribute costs to
projects. Shows project names instead of raw IDs in the UI.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 server/src/services/costs.ts | 55 +++++++++++++++++++++++++++---------
 ui/src/api/costs.ts          |  8 +++---
 ui/src/pages/Costs.tsx       | 10 +++----
 3 files changed, 50 insertions(+), 23 deletions(-)

diff --git a/server/src/services/costs.ts b/server/src/services/costs.ts
index fdb31045..a9011f21 100644
--- a/server/src/services/costs.ts
+++ b/server/src/services/costs.ts
@@ -1,6 +1,6 @@
 import { and, desc, eq, gte, isNotNull, lte, sql } from "drizzle-orm";
 import type { Db } from "@paperclip/db";
-import { agents, companies, costEvents } from "@paperclip/db";
+import { activityLog, agents, companies, costEvents, heartbeatRuns, issues, projects } from "@paperclip/db";
 import { notFound, unprocessable } from "../errors.js";
 
 export interface CostDateRange {
@@ -122,24 +122,51 @@ export function costService(db: Db) {
     },
 
     byProject: async (companyId: string, range?: CostDateRange) => {
-      const conditions: ReturnType<typeof eq>[] = [
-        eq(costEvents.companyId, companyId),
-        isNotNull(costEvents.projectId),
-      ];
-      if (range?.from) conditions.push(gte(costEvents.occurredAt, range.from));
-      if (range?.to) conditions.push(lte(costEvents.occurredAt, range.to));
+      const issueIdAsText = sql<string>`${issues.id}::text`;
+      const runProjectLinks = db
+        .selectDistinctOn([activityLog.runId, issues.projectId], {
+          runId: sql<string>`${activityLog.runId}`,
+          projectId: sql<string>`${issues.projectId}`,
+        })
+        .from(activityLog)
+        .innerJoin(
+          issues,
+          and(
+            eq(activityLog.entityType, "issue"),
+            eq(activityLog.entityId, issueIdAsText),
+          ),
+        )
+        .where(
+          and(
+            eq(activityLog.companyId, companyId),
+            eq(issues.companyId, companyId),
+            isNotNull(activityLog.runId),
+            isNotNull(issues.projectId),
+          ),
+        )
+        .orderBy(activityLog.runId, issues.projectId, desc(activityLog.createdAt))
+        .as("run_project_links");
+
+      const conditions: ReturnType<typeof eq>[] = [eq(heartbeatRuns.companyId, companyId)];
+      if (range?.from) conditions.push(gte(heartbeatRuns.finishedAt, range.from));
+      if (range?.to) conditions.push(lte(heartbeatRuns.finishedAt, range.to));
+
+      const costCentsExpr = sql<number>`coalesce(sum(round(coalesce((${heartbeatRuns.usageJson} ->> 'costUsd')::numeric, 0) * 100)), 0)::int`;
 
       return db
         .select({
-          projectId: costEvents.projectId,
-          costCents: sql<number>`coalesce(sum(${costEvents.costCents}), 0)::int`,
-          inputTokens: sql<number>`coalesce(sum(${costEvents.inputTokens}), 0)::int`,
-          outputTokens: sql<number>`coalesce(sum(${costEvents.outputTokens}), 0)::int`,
+          projectId: runProjectLinks.projectId,
+          projectName: projects.name,
+          costCents: costCentsExpr,
+          inputTokens: sql<number>`coalesce(sum(coalesce((${heartbeatRuns.usageJson} ->> 'inputTokens')::int, 0)), 0)::int`,
+          outputTokens: sql<number>`coalesce(sum(coalesce((${heartbeatRuns.usageJson} ->> 'outputTokens')::int, 0)), 0)::int`,
         })
-        .from(costEvents)
+        .from(runProjectLinks)
+        .innerJoin(heartbeatRuns, eq(runProjectLinks.runId, heartbeatRuns.id))
+        .innerJoin(projects, eq(runProjectLinks.projectId, projects.id))
         .where(and(...conditions))
-        .groupBy(costEvents.projectId)
-        .orderBy(desc(sql`coalesce(sum(${costEvents.costCents}), 0)::int`));
+        .groupBy(runProjectLinks.projectId, projects.name)
+        .orderBy(desc(costCentsExpr));
     },
   };
 }
diff --git a/ui/src/api/costs.ts b/ui/src/api/costs.ts
index bb90fd49..1187e4d0 100644
--- a/ui/src/api/costs.ts
+++ b/ui/src/api/costs.ts
@@ -1,9 +1,9 @@
 import type { CostSummary, CostByAgent } from "@paperclip/shared";
 import { api } from "./client";
 
-export interface CostByEntity {
-  agentId?: string | null;
-  projectId?: string | null;
+export interface CostByProject {
+  projectId: string | null;
+  projectName: string | null;
   costCents: number;
   inputTokens: number;
   outputTokens: number;
@@ -23,5 +23,5 @@ export const costsApi = {
   byAgent: (companyId: string, from?: string, to?: string) =>
     api.get<CostByAgent[]>(`/companies/${companyId}/costs/by-agent${dateParams(from, to)}`),
   byProject: (companyId: string, from?: string, to?: string) =>
-    api.get<CostByEntity[]>(`/companies/${companyId}/costs/by-project${dateParams(from, to)}`),
+    api.get<CostByProject[]>(`/companies/${companyId}/costs/by-project${dateParams(from, to)}`),
 };
diff --git a/ui/src/pages/Costs.tsx b/ui/src/pages/Costs.tsx
index e39d6150..26f10c81 100644
--- a/ui/src/pages/Costs.tsx
+++ b/ui/src/pages/Costs.tsx
@@ -202,16 +202,16 @@ export function Costs() {
               <CardContent className="p-4">
                 <h3 className="text-sm font-semibold mb-3">By Project</h3>
                 {data.byProject.length === 0 ? (
-                  <p className="text-sm text-muted-foreground">No project-attributed costs yet.</p>
+                  <p className="text-sm text-muted-foreground">No project-attributed run costs yet.</p>
                 ) : (
                   <div className="space-y-2">
-                    {data.byProject.map((row, idx) => (
+                    {data.byProject.map((row) => (
                       <div
-                        key={`${row.projectId ?? "na"}-${idx}`}
+                        key={row.projectId ?? "na"}
                         className="flex items-center justify-between text-sm"
                       >
-                        <span className="font-mono text-xs truncate">
-                          {row.projectId ?? "Unattributed"}
+                        <span className="truncate">
+                          {row.projectName ?? row.projectId ?? "Unattributed"}
                         </span>
                         <span className="font-medium">{formatCents(row.costCents)}</span>
                       </div>