feat(dashboard): compute missing costs at query time and fix session grouping

Author: k1yt

src/core/webview/usageStatsMessageHandler.ts

@@ -16,6 +16,7 @@ import { StatsQuery as StatsQuerySchema } from "@roo-code/types"
 import type { ClineProvider } from "./ClineProvider"
 import type { UsageStatsService, JsonExport } from "../../services/stats"
 import { StatsServiceError } from "../../services/stats"
+import { getEffectiveCost } from "../../services/stats/costRecalculation"
 import { resolveDefaultSaveUri, saveLastExportPath } from "../../utils/export"
 import { readTaskMessages } from "../task-persistence/taskMessages"
 
@@ -453,10 +454,63 @@ async function deriveSessionTitle(taskId: string, globalStoragePath: string): Pr
 }
 
 /**
- * Groups usage events by `taskId` and produces a {@link SessionSummary} for
- * each group. The summary uses the first event's model/provider/mode as
- * representative values (a session may span multiple models, but the first
- * event is a reasonable proxy for display purposes).
+ * Resolves the root task ID for a usage event.
+ *
+ * Feature 2: Sessions should be grouped by conversation session (root task),
+ * not by individual subtask. A subtask has a `parentTaskId` pointing to its
+ * parent. By following the parent chain, we can group all subtasks under
+ * their root conversation session.
+ *
+ * Since the event only carries its immediate `parentTaskId` (not the full
+ * chain), we build a parent→children map from the event set and walk up
+ * the chain. If an event has no `parentTaskId`, it IS the root.
+ *
+ * @param event The usage event to resolve.
+ * @param parentMap Map of taskId → parentTaskId (built from the event set).
+ * @returns The root task ID for grouping.
+ */
+function resolveRootTaskId(event: UsageEventV1, parentMap: Map<string, string | undefined>): string {
+	let current = event.taskId
+	const visited = new Set<string>() // Guard against cycles
+
+	while (!visited.has(current)) {
+		visited.add(current)
+		const parent = parentMap.get(current)
+		if (!parent) break // No parent → this is the root
+		current = parent
+	}
+
+	return current
+}
+
+/**
+ * Builds a map of taskId → parentTaskId from a set of usage events.
+ * This allows resolving the root task for any event in the set.
+ */
+function buildParentMap(events: UsageEventV1[]): Map<string, string | undefined> {
+	const parentMap = new Map<string, string | undefined>()
+	for (const event of events) {
+		if (!parentMap.has(event.taskId)) {
+			parentMap.set(event.taskId, event.parentTaskId)
+		}
+	}
+	return parentMap
+}
+
+/**
+ * Groups usage events by their root conversation session and produces a
+ * {@link SessionSummary} for each group.
+ *
+ * Feature 2: Events are grouped by root task ID (following `parentTaskId`
+ * chains) so that subtasks appear under their parent conversation session.
+ * If an event has no `parentTaskId`, it is its own root.
+ *
+ * Feature 1: Missing `costUsd` values are computed on-the-fly using the
+ * model's pricing info. The NDJSON store is never modified.
+ *
+ * The summary uses the first event's model/provider/mode as representative
+ * values (a session may span multiple models, but the first event is a
+ * reasonable proxy for display purposes).
  *
  * @param events Filtered usage events (already scoped to the requested time
  *   range and `includeCancelled` policy).
@@ -466,14 +520,18 @@ async function buildSessionSummaries(
 	events: UsageEventV1[],
 	globalStoragePath: string,
 ): Promise<SessionSummary[]> {
-	// Group events by taskId, preserving insertion order for determinism.
+	// Feature 2: Build parent map and group by root task ID.
+	const parentMap = buildParentMap(events)
+
+	// Group events by root taskId, preserving insertion order for determinism.
 	const groups = new Map<string, UsageEventV1[]>()
 	for (const event of events) {
-		const list = groups.get(event.taskId)
+		const rootTaskId = resolveRootTaskId(event, parentMap)
+		const list = groups.get(rootTaskId)
 		if (list) {
 			list.push(event)
 		} else {
-			groups.set(event.taskId, [event])
+			groups.set(rootTaskId, [event])
 		}
 	}
 
@@ -491,11 +549,12 @@ async function buildSessionSummaries(
 		const last = sorted[sorted.length - 1]
 
 		// Aggregate totals across all events in the task.
+		// Feature 1: Use getEffectiveCost to compute missing costs on-the-fly.
 		let totalTokens = 0
 		let totalCost = 0
 		for (const ev of sorted) {
 			totalTokens += ev.usage.totalTokens?.value ?? 0
-			totalCost += ev.usage.costUsd?.value ?? 0
+			totalCost += getEffectiveCost(ev)
 		}
 
 		const title = await deriveSessionTitle(taskId, globalStoragePath)
@@ -635,7 +694,8 @@ function mapEventToApiCall(event: UsageEventV1, index: number): APICallRecord {
 		cacheReadTokens: event.usage.cacheReadTokens?.value ?? 0,
 		cacheWriteTokens: event.usage.cacheWriteTokens?.value ?? 0,
 		reasoningTokens: event.usage.reasoningTokens?.value ?? 0,
-		costUsd: event.usage.costUsd?.value ?? 0,
+		// Feature 1: Compute missing cost on-the-fly from model pricing.
+		costUsd: getEffectiveCost(event),
 		status: event.status,
 		model: event.model,
 	}
@@ -667,11 +727,12 @@ async function buildSessionDetail(
 	const last = sorted[sorted.length - 1]
 
 	// Aggregate totals across all events in the task.
+	// Feature 1: Use getEffectiveCost to compute missing costs on-the-fly.
 	let totalTokens = 0
 	let totalCost = 0
 	for (const ev of sorted) {
 		totalTokens += ev.usage.totalTokens?.value ?? 0
-		totalCost += ev.usage.costUsd?.value ?? 0
+		totalCost += getEffectiveCost(ev)
 	}
 
 	const title = await deriveSessionTitle(taskId, globalStoragePath)
@@ -760,8 +821,12 @@ export async function handleGetDashboardSessionDetail(
 		const exportData = await service.exportStats(allQuery, "json")
 		const allEvents: UsageEventV1[] = (exportData as JsonExport).events ?? []
 
-		// Filter to the requested task.
-		const taskEvents = allEvents.filter((ev) => ev.taskId === taskId)
+		// Feature 2: Filter to the requested root task AND its subtasks.
+		// The session list groups events by root task ID, so clicking a
+		// session row passes the root task ID. We need to include events
+		// from all subtasks whose root resolves to this taskId.
+		const parentMap = buildParentMap(allEvents)
+		const taskEvents = allEvents.filter((ev) => resolveRootTaskId(ev, parentMap) === taskId)
 
 		if (taskEvents.length === 0) {
 			// No events for this task — return an empty detail rather than an

src/services/stats/UsageAggregator.ts

@@ -7,6 +7,8 @@ import type {
 	UsageValueSource,
 } from "@roo-code/types"
 
+import { getEffectiveCost, computeEventCost } from "./costRecalculation"
+
 // ── Types ───────────────────────────────────────────────────────────────────
 
 /** Internal event representation used for aggregation (UsageEventV1 + derived fields) */
@@ -395,24 +397,33 @@ export class UsageAggregator {
 			case "status":
 				return [event.status]
 			case "source": {
-				// Separate by the source of costUsd
-				// If the event has costUsd, use its source; otherwise "unknown"
-				const sources = new Set<string>()
-				if (event.usage.costUsd) {
-					sources.add(event.usage.costUsd.source)
-				}
-				// Also consider the source of input/output tokens
-				if (event.usage.inputTokens) {
-					sources.add(event.usage.inputTokens.source)
-				}
-				if (event.usage.outputTokens) {
-					sources.add(event.usage.outputTokens.source)
+					// Separate by the source of costUsd.
+					// Feature 1: If the event has no costUsd but the cost can be
+					// computed on-the-fly from model pricing, treat the source as
+					// "estimated" (since it is derived, not provider-reported).
+					const sources = new Set<string>()
+					if (event.usage.costUsd) {
+						sources.add(event.usage.costUsd.source)
+					} else {
+						// Check if cost can be computed; if so, mark as "estimated".
+						// Otherwise the source remains "unknown".
+						const computedCost = computeEventCost(event)
+						if (computedCost > 0) {
+							sources.add("estimated")
+						}
+					}
+					// Also consider the source of input/output tokens
+					if (event.usage.inputTokens) {
+						sources.add(event.usage.inputTokens.source)
+					}
+					if (event.usage.outputTokens) {
+						sources.add(event.usage.outputTokens.source)
+					}
+					if (sources.size === 0) {
+						sources.add("unknown")
+					}
+					return Array.from(sources)
 				}
-				if (sources.size === 0) {
-					sources.add("unknown")
-				}
-				return Array.from(sources)
-			}
 			default:
 				return []
 		}
@@ -451,7 +462,9 @@ export class UsageAggregator {
 		const cacheWriteTokens = this.extractValue(event.usage.cacheWriteTokens)
 		const reasoningTokens = this.extractValue(event.usage.reasoningTokens)
 		const totalTokens = this.extractValue(event.usage.totalTokens)
-		const costUsd = this.extractValue(event.usage.costUsd)
+		// Feature 1: If costUsd is missing on old events, compute it on-the-fly
+		// from the model's pricing info. Never modifies the stored event.
+		const costUsd = getEffectiveCost(event)
 
 		// Inclusion semantics check
 		const hasUnknownInclusion =

src/services/stats/__tests__/UsageAggregator.spec.ts

@@ -491,7 +491,12 @@ describe("UsageAggregator", () => {
 			expect(result.totals.cacheWriteTokens).toBe(0)
 			expect(result.totals.reasoningTokens).toBe(0)
 			expect(result.totals.totalTokens).toBe(0)
-			expect(result.totals.costUsd).toBe(0)
+			// Feature 1: When costUsd is missing, the aggregator now computes
+			// the cost on-the-fly from the model's pricing info. The default
+			// test event uses provider "anthropic" + model "claude-sonnet-4-20250514"
+			// with 1000 input tokens. Anthropic pricing: $3/1M input tokens →
+			// 1000 × 3 / 1_000_000 = 0.003.
+			expect(result.totals.costUsd).toBeCloseTo(0.003, 5)
 		})
 	})