claude-attribution 1.8.0 → 1.9.0

package/src/metrics/collect.ts

@@ -9,10 +9,12 @@ import { readFile, readdir, stat } from "fs/promises";
 import { calculateCostUsd } from "../pricing.ts";
 import { existsSync } from "fs";
 import { resolve, join, relative } from "path";
-import { homedir } from "os";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { parseTranscript, type TranscriptResult } from "./transcript.ts";
+import { resolveCopilotSessionId } from "./copilot-session.ts";
+import { resolveClaudeProjectDir } from "./claude-projects.ts";
+import { parseLocalSession } from "./local-session.ts";
+import { type TranscriptResult } from "./transcript.ts";
 import {
 	listNotes,
 	readNote,
@@ -127,27 +129,35 @@ async function resolveSessionId(repoRoot: string): Promise<string | null> {
 	}
 
 	// Strategy 2: most recently modified top-level session JSONL in ~/.claude/projects/<key>/
-	const projectKey = repoRoot.replace(/\//g, "-");
-	const transcriptDir = join(homedir(), ".claude", "projects", projectKey);
-	if (!existsSync(transcriptDir)) return null;
-	try {
-		const files = await readdir(transcriptDir);
-		const sessionFiles = files.filter(
-			(f) => f.endsWith(".jsonl") && SESSION_ID_RE.test(f.slice(0, -6)),
-		);
-		if (sessionFiles.length === 0) return null;
-		// Pick the most recently modified
-		const withMtimes = await Promise.all(
-			sessionFiles.map(async (f) => ({
-				id: f.slice(0, -6),
-				mtime: (await stat(join(transcriptDir, f))).mtimeMs,
-			})),
-		);
-		withMtimes.sort((a, b) => b.mtime - a.mtime);
-		return withMtimes[0]?.id ?? null;
-	} catch {
-		return null;
+	const transcriptDir = await resolveClaudeProjectDir(repoRoot);
+	if (transcriptDir && existsSync(transcriptDir)) {
+		try {
+			const files = await readdir(transcriptDir);
+			const sessionFiles = files.filter(
+				(f) => f.endsWith(".jsonl") && SESSION_ID_RE.test(f.slice(0, -6)),
+			);
+			if (sessionFiles.length > 0) {
+				const withMtimes = await Promise.all(
+					sessionFiles.map(async (f) => ({
+						id: f.slice(0, -6),
+						mtime: (await stat(join(transcriptDir, f))).mtimeMs,
+					})),
+				);
+				withMtimes.sort((a, b) => b.mtime - a.mtime);
+				return withMtimes[0]?.id ?? null;
+			}
+		} catch {
+			// Fall through to Copilot session-state fallback.
+		}
 	}
+
+	const copilotSessionId = await resolveCopilotSessionId(repoRoot).catch(
+		() => null,
+	);
+	if (copilotSessionId && SESSION_ID_RE.test(copilotSessionId)) {
+		return copilotSessionId;
+	}
+	return null;
 }
 
 async function getBranchAttribution(
@@ -259,6 +269,15 @@ function transcriptFromAttribution(
 		humanMinutes: sessionMetrics?.humanMinutes ?? 0,
 		toolCounts: sessionMetrics?.toolCounts ?? {},
 		skillNames: sessionMetrics?.skillNames ?? [],
+		agentCounts: sessionMetrics?.agentCounts ?? {},
+		provider:
+			result.assistantRuntime?.vendor === "copilot" ? "copilot" : "claude",
+		costMode:
+			result.assistantRuntime?.vendor === "copilot" ? "unavailable" : "estimated",
+		costDescription:
+			result.assistantRuntime?.vendor === "copilot"
+				? "Copilot session data does not expose enough local billing data to estimate spend reliably."
+				: undefined,
 	};
 }
 
@@ -347,7 +366,7 @@ export async function collectMetrics(
 					id,
 					sessionStart ?? undefined,
 				).catch(() => []),
-				parseTranscript(id, root).catch(() => null),
+				parseLocalSession(id, root).catch(() => null),
 			]);
 			return {
 				sessionId: id,
@@ -447,6 +466,58 @@ function formatSessionLine(transcript: TranscriptResult): string {
 	return parts.join(" · ");
 }
 
+function renderModelUsage(
+	out: (line?: string) => void,
+	transcript: TranscriptResult,
+): void {
+	if (transcript.provider === "copilot") {
+		out("| Model | Calls | Known Tokens |");
+		out("|-------|-------|--------------|");
+		for (const model of transcript.byModel) {
+			out(
+				`| ${model.modelFull} | ${model.calls} | ${kFormat(model.outputTokens)} |`,
+			);
+		}
+		out(
+			`| **Total** | ${transcript.totals.totalCalls} | ${kFormat(transcript.totals.totalOutputTokens)} |`,
+		);
+		out();
+		out(
+			`**Estimated cost:** unavailable — ${transcript.costDescription ?? "Copilot session data does not expose enough local billing data to estimate spend reliably."}`,
+		);
+		out();
+		return;
+	}
+
+	out("| Model | Calls | Input | Output | Cache |");
+	out("|-------|-------|-------|--------|-------|");
+	for (const model of transcript.byModel) {
+		const cache = model.cacheCreationTokens + model.cacheReadTokens;
+		out(
+			`| ${model.modelShort} | ${model.calls} | ${kFormat(model.inputTokens)} | ${kFormat(model.outputTokens)} | ${kFormat(cache)} |`,
+		);
+	}
+	const { totals } = transcript;
+	const totalCache = totals.totalCacheCreationTokens + totals.totalCacheReadTokens;
+	out(
+		`| **Total** | ${totals.totalCalls} | ${kFormat(totals.totalInputTokens)} | ${kFormat(totals.totalOutputTokens)} | ${kFormat(totalCache)} |`,
+	);
+	out();
+	const cost = calculateCostUsd(
+		transcript.byModel.map((model) => ({
+			modelFull: model.modelFull,
+			modelShort: model.modelShort,
+			calls: model.calls,
+			inputTokens: model.inputTokens,
+			outputTokens: model.outputTokens,
+			cacheCreationTokens: model.cacheCreationTokens,
+			cacheReadTokens: model.cacheReadTokens,
+		})),
+	);
+	out(`**Estimated cost:** ~$${cost.toFixed(2)}`);
+	out();
+}
+
 export function renderMetrics(data: MetricsData): string {
 	const {
 		repoRoot,
@@ -473,7 +544,7 @@ export function renderMetrics(data: MetricsData): string {
 		).values(),
 	];
 
-	out("## Claude Code Metrics");
+	out("## AI Coding Metrics");
 	out();
 
 	// Headline: AI% (most important stat, shown first)
@@ -495,7 +566,7 @@ export function renderMetrics(data: MetricsData): string {
 					? Math.round((prTotal / minimapTotals.total) * 100)
 					: 0;
 			out(
-				`**This PR:** ${prTotal} lines changed (${codebasePct}% of codebase) · ${prPctAi}% Claude edits · ${prAi} AI lines`,
+				`**This PR:** ${prTotal} lines changed (${codebasePct}% of codebase) · ${prPctAi}% AI edits · ${prAi} AI lines`,
 			);
 		}
 		out();
@@ -532,39 +603,16 @@ export function renderMetrics(data: MetricsData): string {
 
 	// Model usage table
 	if (transcript) {
-		out("| Model | Calls | Input | Output | Cache |");
-		out("|-------|-------|-------|--------|-------|");
-		for (const m of transcript.byModel) {
-			const cache = m.cacheCreationTokens + m.cacheReadTokens;
-			out(
-				`| ${m.modelShort} | ${m.calls} | ${kFormat(m.inputTokens)} | ${kFormat(m.outputTokens)} | ${kFormat(cache)} |`,
-			);
-		}
-		const { totals: t } = transcript;
-		const totalCache = t.totalCacheCreationTokens + t.totalCacheReadTokens;
-		out(
-			`| **Total** | ${t.totalCalls} | ${kFormat(t.totalInputTokens)} | ${kFormat(t.totalOutputTokens)} | ${kFormat(totalCache)} |`,
-		);
-		out();
-		const cost = calculateCostUsd(
-			transcript.byModel.map((m) => ({
-				modelFull: m.modelFull,
-				modelShort: m.modelShort,
-				calls: m.calls,
-				inputTokens: m.inputTokens,
-				outputTokens: m.outputTokens,
-				cacheCreationTokens: m.cacheCreationTokens,
-				cacheReadTokens: m.cacheReadTokens,
-			})),
-		);
-		out(`**Estimated cost:** ~$${cost.toFixed(2)}`);
-		out();
+		renderModelUsage(out, transcript);
 	}
 
 	// Multi-session rollup (shown when multiple Claude sessions contributed)
 	if (allTranscripts.length > 1) {
 		out(`### All Sessions on This Branch (${allTranscripts.length} sessions)`);
 		out();
+		const hasCopilotSession = allTranscripts.some(
+			(transcriptItem) => transcriptItem.provider === "copilot",
+		);
 		const agg = allTranscripts.reduce(
 			(acc, t) => ({
 				totalCalls: acc.totalCalls + t.totals.totalCalls,
@@ -590,11 +638,19 @@ export function renderMetrics(data: MetricsData): string {
 				activeMinutes: 0,
 			},
 		);
-		out("| API Calls | Input Tokens | Output Tokens | Cache Tokens |");
-		out("|-----------|--------------|---------------|--------------|");
-		out(
-			`| ${agg.totalCalls} | ${kFormat(agg.totalInputTokens)} | ${kFormat(agg.totalOutputTokens)} | ${kFormat(agg.totalCacheTokens)} |`,
-		);
+		if (hasCopilotSession) {
+			const knownTokens =
+				agg.totalInputTokens + agg.totalOutputTokens + agg.totalCacheTokens;
+			out("| API Calls | Known Tokens |");
+			out("|-----------|--------------|");
+			out(`| ${agg.totalCalls} | ${kFormat(knownTokens)} |`);
+		} else {
+			out("| API Calls | Input Tokens | Output Tokens | Cache Tokens |");
+			out("|-----------|--------------|---------------|--------------|");
+			out(
+				`| ${agg.totalCalls} | ${kFormat(agg.totalInputTokens)} | ${kFormat(agg.totalOutputTokens)} | ${kFormat(agg.totalCacheTokens)} |`,
+			);
+		}
 		out();
 		const aggSessionLine = [
 			`${agg.humanPromptCount} prompt${agg.humanPromptCount === 1 ? "" : "s"}`,

package/src/metrics/copilot-session.ts

@@ -0,0 +1,383 @@
+import { existsSync } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import type { TranscriptResult, ModelUsage } from "./transcript.ts";
+
+interface CopilotSessionContext {
+	cwd?: string;
+	gitRoot?: string;
+	branch?: string;
+}
+
+interface CopilotEvent {
+	type?: string;
+	timestamp?: string;
+	data?: Record<string, unknown>;
+}
+
+interface TimedMessage {
+	type: "human" | "assistant";
+	ts: number;
+}
+
+function modelShort(full: string): ModelUsage["modelShort"] {
+	if (/opus/i.test(full)) return "Opus";
+	if (/sonnet/i.test(full)) return "Sonnet";
+	if (/haiku/i.test(full)) return "Haiku";
+	return "Unknown";
+}
+
+function copilotHomeDir(): string {
+	return process.env["COPILOT_HOME"] ?? join(process.env["HOME"] ?? homedir(), ".copilot");
+}
+
+function copilotSessionStateRoot(): string {
+	return join(copilotHomeDir(), "session-state");
+}
+
+function normalizeSessionPath(pathValue: unknown): string | null {
+	return typeof pathValue === "string" && pathValue.trim()
+		? resolve(pathValue)
+		: null;
+}
+
+function markerWindow(events: CopilotEvent[]): { start: number | null; end: number | null } {
+	let start: number | null = null;
+	let end: number | null = null;
+
+	for (const event of events) {
+		if (event.type !== "user.message" || !event.timestamp) continue;
+		const content = (event.data?.["content"] ?? event.data?.["transformedContent"]) as
+			| string
+			| undefined;
+		if (!content) continue;
+		const ts = new Date(event.timestamp).getTime();
+		if (!isFinite(ts)) continue;
+		const normalized = content.trim().toLowerCase();
+		if (/^start work\b/.test(normalized)) {
+			start = ts;
+			end = null;
+			continue;
+		}
+		if (start !== null && end === null && /^create pr\b/.test(normalized)) {
+			end = ts;
+			break;
+		}
+	}
+
+	return { start, end };
+}
+
+function inWindow(
+	timestamp: string | undefined,
+	window: { start: number | null; end: number | null },
+): boolean {
+	if (!timestamp) return false;
+	const ts = new Date(timestamp).getTime();
+	if (!isFinite(ts)) return false;
+	if (window.start !== null && ts < window.start) return false;
+	if (window.end !== null && ts > window.end) return false;
+	return true;
+}
+
+function computeTimeBreakdown(messages: TimedMessage[]): {
+	totalMinutes: number;
+	aiMinutes: number;
+	humanMinutes: number;
+} {
+	const sorted = [...messages].sort((a, b) => a.ts - b.ts);
+	const IDLE_MS = 900_000;
+
+	let aiMs = 0;
+	let humanMs = 0;
+
+	for (let i = 1; i < sorted.length; i++) {
+		const prev = sorted[i - 1]!;
+		const curr = sorted[i]!;
+		const gap = curr.ts - prev.ts;
+		if (gap >= IDLE_MS) continue;
+		if (prev.type === "human") {
+			aiMs += gap;
+		} else {
+			humanMs += gap;
+		}
+	}
+
+	return {
+		aiMinutes: Math.round(aiMs / 60_000),
+		humanMinutes: Math.round(humanMs / 60_000),
+		totalMinutes: Math.round((aiMs + humanMs) / 60_000),
+	};
+}
+
+async function readEvents(filePath: string): Promise<CopilotEvent[]> {
+	const raw = await readFile(filePath, "utf8");
+	const events: CopilotEvent[] = [];
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			events.push(JSON.parse(trimmed) as CopilotEvent);
+		} catch {
+			// Skip malformed lines.
+		}
+	}
+	return events;
+}
+
+function sessionContext(events: CopilotEvent[]): CopilotSessionContext {
+	let context: CopilotSessionContext = {};
+	for (const event of events) {
+		if (event.type === "session.start") {
+			const startContext = event.data?.["context"];
+			if (typeof startContext === "object" && startContext !== null) {
+				const contextData = startContext as Record<string, unknown>;
+				context = {
+					cwd:
+						typeof contextData["cwd"] === "string"
+							? contextData["cwd"]
+							: context.cwd,
+					gitRoot:
+						typeof contextData["gitRoot"] === "string"
+							? contextData["gitRoot"]
+							: context.gitRoot,
+					branch:
+						typeof contextData["branch"] === "string"
+							? contextData["branch"]
+							: context.branch,
+				};
+			}
+		}
+		if (event.type === "session.context_changed") {
+			context = {
+				cwd:
+					typeof event.data?.["cwd"] === "string"
+						? (event.data["cwd"] as string)
+						: context.cwd,
+				gitRoot:
+					typeof event.data?.["gitRoot"] === "string"
+						? (event.data["gitRoot"] as string)
+						: context.gitRoot,
+				branch:
+					typeof event.data?.["branch"] === "string"
+						? (event.data["branch"] as string)
+						: context.branch,
+			};
+		}
+	}
+	return context;
+}
+
+async function sessionDirs(root = copilotSessionStateRoot()): Promise<string[]> {
+	if (!existsSync(root)) return [];
+	return (await readdir(root, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, "events.jsonl")))
+		.map((entry) => join(root, entry.name));
+}
+
+export async function resolveCopilotSessionId(
+	repoRoot: string,
+	branch?: string | null,
+	root = copilotSessionStateRoot(),
+): Promise<string | null> {
+	const resolvedRepo = resolve(repoRoot);
+	const dirs = await sessionDirs(root);
+	const candidates: Array<{ id: string; score: number; mtime: number }> = [];
+
+	for (const dir of dirs) {
+		const events = await readEvents(join(dir, "events.jsonl"));
+		const context = sessionContext(events);
+		const sessionRepo =
+			normalizeSessionPath(context.gitRoot) ?? normalizeSessionPath(context.cwd);
+		if (sessionRepo !== resolvedRepo) continue;
+		const dirStat = await stat(join(dir, "events.jsonl"));
+		let score = 1;
+		if (branch && context.branch === branch) score += 2;
+		candidates.push({ id: dir.split("/").at(-1) ?? "", score, mtime: dirStat.mtimeMs });
+	}
+
+	candidates.sort((a, b) => b.score - a.score || b.mtime - a.mtime);
+	return candidates[0]?.id ?? null;
+}
+
+export async function parseCopilotSession(
+	sessionId: string,
+	repoRoot?: string,
+	root = copilotSessionStateRoot(),
+): Promise<TranscriptResult | null> {
+	const eventsPath = join(root, sessionId, "events.jsonl");
+	if (!existsSync(eventsPath)) return null;
+
+	const events = await readEvents(eventsPath);
+	const context = sessionContext(events);
+	if (repoRoot) {
+		const expectedRepo = resolve(repoRoot);
+		const actualRepo =
+			normalizeSessionPath(context.gitRoot) ?? normalizeSessionPath(context.cwd);
+		if (actualRepo && actualRepo !== expectedRepo) return null;
+	}
+
+	const window = markerWindow(events);
+	const toolCounts = new Map<string, number>();
+	const skillNames = new Set<string>();
+	const agentCounts = new Map<string, number>();
+	const timedMessages: TimedMessage[] = [];
+	let humanPromptCount = 0;
+	let mainModel: string | null = null;
+	const mainModelVotes = new Map<string, number>();
+	let mainAssistantCalls = 0;
+	let mainKnownTokens = 0;
+	const byModel = new Map<string, ModelUsage>();
+
+	for (const event of events) {
+		if (!inWindow(event.timestamp, window)) continue;
+
+		if (event.type === "user.message") {
+			humanPromptCount++;
+			const ts = new Date(event.timestamp ?? "").getTime();
+			if (isFinite(ts)) timedMessages.push({ type: "human", ts });
+			continue;
+		}
+
+		if (event.type === "assistant.turn_end") {
+			const ts = new Date(event.timestamp ?? "").getTime();
+			if (isFinite(ts)) timedMessages.push({ type: "assistant", ts });
+			continue;
+		}
+
+		if (event.type === "tool.execution_start") {
+			const toolName = typeof event.data?.["toolName"] === "string"
+				? (event.data["toolName"] as string)
+				: null;
+			if (toolName) {
+				toolCounts.set(toolName, (toolCounts.get(toolName) ?? 0) + 1);
+				if (
+					toolName === "skill" &&
+					typeof (event.data?.["arguments"] as Record<string, unknown> | undefined)?.["skill"] ===
+						"string"
+				) {
+					skillNames.add(
+						((event.data?.["arguments"] as Record<string, unknown>)["skill"] as string),
+					);
+				}
+			}
+			continue;
+		}
+
+		if (event.type === "subagent.started") {
+			const agentName =
+				(typeof event.data?.["agentName"] === "string"
+					? (event.data["agentName"] as string)
+					: null) ??
+				(typeof event.data?.["agentDisplayName"] === "string"
+					? (event.data["agentDisplayName"] as string)
+					: null);
+			if (agentName) {
+				agentCounts.set(agentName, (agentCounts.get(agentName) ?? 0) + 1);
+			}
+			continue;
+		}
+
+		if (event.type === "tool.execution_complete") {
+			const model = typeof event.data?.["model"] === "string"
+				? (event.data["model"] as string)
+				: null;
+			if (model && !event.data?.["parentToolCallId"]) {
+				mainModelVotes.set(model, (mainModelVotes.get(model) ?? 0) + 1);
+			}
+			continue;
+		}
+
+		if (event.type === "assistant.message") {
+			const parentToolCallId = event.data?.["parentToolCallId"];
+			if (parentToolCallId) continue;
+			mainAssistantCalls++;
+			const outputTokens =
+				typeof event.data?.["outputTokens"] === "number"
+					? (event.data["outputTokens"] as number)
+					: 0;
+			mainKnownTokens += outputTokens;
+			continue;
+		}
+
+		if (event.type === "subagent.completed") {
+			const model = typeof event.data?.["model"] === "string"
+				? (event.data["model"] as string)
+				: null;
+			if (!model) continue;
+			const usage = byModel.get(model) ?? {
+				modelShort: modelShort(model),
+				modelFull: model,
+				calls: 0,
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheCreationTokens: 0,
+				cacheReadTokens: 0,
+			};
+			usage.calls += 1;
+			if (typeof event.data?.["totalTokens"] === "number") {
+				usage.outputTokens += event.data["totalTokens"] as number;
+			}
+			byModel.set(model, usage);
+		}
+	}
+
+	mainModel =
+		[...mainModelVotes.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
+	if (mainModel) {
+		const usage = byModel.get(mainModel) ?? {
+			modelShort: modelShort(mainModel),
+			modelFull: mainModel,
+			calls: 0,
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheCreationTokens: 0,
+			cacheReadTokens: 0,
+		};
+		usage.calls += mainAssistantCalls;
+		usage.outputTokens += mainKnownTokens;
+		byModel.set(mainModel, usage);
+	}
+
+	const byModelValues = [...byModel.values()].sort((a, b) =>
+		a.modelShort.localeCompare(b.modelShort),
+	);
+	const totals = byModelValues.reduce(
+		(acc, model) => ({
+			totalCalls: acc.totalCalls + model.calls,
+			totalInputTokens: acc.totalInputTokens + model.inputTokens,
+			totalOutputTokens: acc.totalOutputTokens + model.outputTokens,
+			totalCacheCreationTokens:
+				acc.totalCacheCreationTokens + model.cacheCreationTokens,
+			totalCacheReadTokens: acc.totalCacheReadTokens + model.cacheReadTokens,
+		}),
+		{
+			totalCalls: 0,
+			totalInputTokens: 0,
+			totalOutputTokens: 0,
+			totalCacheCreationTokens: 0,
+			totalCacheReadTokens: 0,
+		},
+	);
+
+	const { totalMinutes, aiMinutes, humanMinutes } =
+		computeTimeBreakdown(timedMessages);
+
+	return {
+		sessionId,
+		byModel: byModelValues,
+		totals,
+		humanPromptCount,
+		activeMinutes: totalMinutes,
+		aiMinutes,
+		humanMinutes,
+		toolCounts: Object.fromEntries(toolCounts),
+		skillNames: [...skillNames].sort((a, b) => a.localeCompare(b)),
+		agentCounts: Object.fromEntries(agentCounts),
+		provider: "copilot",
+		costMode: "unavailable",
+		costDescription:
+			"Copilot session data exposes timing, tool, and model signals, but not enough local billing data to estimate spend reliably.",
+	};
+}

package/src/metrics/local-session.ts

@@ -0,0 +1,12 @@
+import { parseCopilotSession } from "./copilot-session.ts";
+import { parseTranscript, type TranscriptResult } from "./transcript.ts";
+
+export async function parseLocalSession(
+	sessionId: string,
+	repoRoot?: string,
+): Promise<TranscriptResult | null> {
+	return (
+		(await parseTranscript(sessionId, repoRoot).catch(() => null)) ??
+		(await parseCopilotSession(sessionId, repoRoot).catch(() => null))
+	);
+}

package/src/metrics/session-metrics.ts

@@ -53,6 +53,23 @@ export const BORING_TOOLS = new Set([
 	"Skill",
 	// Agent is tracked in agentCounts via agent-activity.jsonl
 	"Agent",
+	// Copilot CLI internal / routine tools
+	"view",
+	"glob",
+	"rg",
+	"bash",
+	"write_bash",
+	"read_bash",
+	"stop_bash",
+	"report_intent",
+	"task",
+	"read_agent",
+	"ask_user",
+	"sql",
+	"apply_patch",
+	"list_bash",
+	"list_agents",
+	"skill",
 ]);
 
 export async function readJsonlForSession<
@@ -131,6 +148,11 @@ export function buildSessionMetrics(
 		const type = entry.subagentType ?? "unknown";
 		agentCounts.set(type, (agentCounts.get(type) ?? 0) + 1);
 	}
+	if (agentCounts.size === 0 && transcript?.agentCounts) {
+		for (const [agent, count] of Object.entries(transcript.agentCounts)) {
+			agentCounts.set(agent, (agentCounts.get(agent) ?? 0) + count);
+		}
+	}
 
 	return {
 		toolCounts: countRecordFromMap(toolCounts),