agent-optic 0.3.0 → 0.4.0

package/examples/annotate-commits.ts

@@ -2,35 +2,40 @@
 /**
  * annotate-commits.ts — Write AI cost data as git notes on each commit in .ai-usage.jsonl
  *
+ * Uses the refs/notes/ai namespace (compatible with git-ai tooling).
+ * Each note has a human-readable summary line followed by a machine-readable JSON section.
+ *
  * Usage:
  *   bun examples/annotate-commits.ts [path-to-repo]   # default: cwd
  *   bun examples/annotate-commits.ts --push           # also push notes to origin
  *
- * After running, git log --show-notes displays AI cost inline:
+ * After running, git log --show-notes=ai displays AI cost inline:
  *
  *   commit ad7ac31...
  *       Fix messageCount: also exclude toolUseResult carriers
  *
- *   Notes:
+ *   Notes (ai):
  *       AI: $2.71 | out: 21K | cache: 5.8M | sessions: 9 | claude-sonnet-4-6
+ *       ---
+ *       {"schema":"agent-optic/1.0","cost_usd":2.71,...}
  */
 
 import { join } from "node:path";
 import { existsSync } from "node:fs";
+import { fmtTokens } from "./git-helpers.js";
+
+const NOTES_REF = "refs/notes/ai";
 
 interface UsageRecord {
 	commit: string;
+	branch?: string;
 	tokens: { input: number; output: number; cache_read: number; cache_write: number };
 	cost_usd: number;
 	models: string[];
 	session_ids: string[];
-}
-
-function fmt(n: number): string {
-	if (n >= 1_000_000_000) return (n / 1_000_000_000).toFixed(1) + "B";
-	if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + "M";
-	if (n >= 1_000) return (n / 1_000).toFixed(0) + "K";
-	return String(n);
+	messages?: number;
+	files_changed?: number;
+	ai_tool?: string;
 }
 
 // ── CLI args ──────────────────────────────────────────────────────────
@@ -68,15 +73,29 @@ let skipped = 0;
 for (const r of records) {
 	const model = r.models[0] ?? "unknown";
 
-	const note = [
+	const summary = [
 		`AI: $${r.cost_usd.toFixed(2)}`,
-		`out: ${fmt(r.tokens.output)}`,
-		`cache: ${fmt(r.tokens.cache_read)}`,
+		`out: ${fmtTokens(r.tokens.output)}`,
+		`cache: ${fmtTokens(r.tokens.cache_read)}`,
 		`sessions: ${r.session_ids.length}`,
 		model,
 	].join(" | ");
 
-	const proc = Bun.spawn(["git", "notes", "add", "-f", "-m", note, r.commit], {
+	const meta = JSON.stringify({
+		schema: "agent-optic/1.0",
+		sessions: r.session_ids,
+		tokens: r.tokens,
+		cost_usd: r.cost_usd,
+		models: r.models,
+		...(r.branch ? { branch: r.branch } : {}),
+		...(r.messages !== undefined ? { messages: r.messages } : {}),
+		...(r.files_changed !== undefined ? { files_changed: r.files_changed } : {}),
+		...(r.ai_tool ? { ai_tool: r.ai_tool } : {}),
+	});
+
+	const note = `${summary}\n---\n${meta}`;
+
+	const proc = Bun.spawn(["git", "notes", "--ref", NOTES_REF, "add", "-f", "-m", note, r.commit], {
 		cwd: repoPath,
 		stdout: "pipe",
 		stderr: "pipe",
@@ -96,13 +115,13 @@ for (const r of records) {
 }
 
 console.log(`${annotated} commits annotated, ${skipped} skipped (not in this repo)`);
-console.log(`\nView with: git log --show-notes`);
+console.log(`\nView with: git log --show-notes=ai`);
 
 // ── Push notes ────────────────────────────────────────────────────────
 
 if (push) {
 	console.log("\nPushing notes to origin...");
-	const proc = Bun.spawn(["git", "push", "origin", "refs/notes/commits"], {
+	const proc = Bun.spawn(["git", "push", "origin", `${NOTES_REF}:${NOTES_REF}`], {
 		cwd: repoPath,
 		stdout: "pipe",
 		stderr: "pipe",
@@ -112,7 +131,7 @@ if (push) {
 	const err = await new Response(proc.stderr).text();
 	if (exitCode === 0) {
 		console.log("Notes pushed. Others can fetch with:");
-		console.log("  git fetch origin refs/notes/commits:refs/notes/commits");
+		console.log(`  git fetch origin ${NOTES_REF}:${NOTES_REF}`);
 	} else {
 		console.error("Push failed:", err.trim() || out.trim());
 	}

package/examples/branch-report.ts

@@ -10,6 +10,7 @@
  */
 
 import { basename, resolve } from "node:path";
+import { fmtTokens } from "./git-helpers.js";
 
 // ── Types ─────────────────────────────────────────────────────────────────────
 
@@ -51,12 +52,6 @@ interface BranchStats {
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
-function fmtTokens(n: number): string {
-	if (n >= 1_000_000_000) return `${(n / 1_000_000_000).toFixed(1)}B`;
-	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-	if (n >= 1_000) return `${(n / 1_000).toFixed(0)}K`;
-	return String(n);
-}
 
 function fmtCost(usd: number): string {
 	if (usd >= 100) return `$${usd.toFixed(0)}`;

package/examples/commit-tracker.ts

@@ -12,7 +12,8 @@
  * a local assistant session (within a configurable time window).
  */
 
-import { createHistory, estimateCost, projectName, type SessionMeta } from "../src/index.js";
+import { createHistory, estimateCost, projectName, detectAgentFromCommit, type SessionMeta } from "../src/index.js";
+import { resolveCommitBranches, findMatchingSessions } from "./git-helpers.js";
 import { resolve, join } from "node:path";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
@@ -115,16 +116,18 @@ interface CommitInfo {
 	timestamp: number;
 	branch: string;
 	author: string;
+	authorEmail: string;
 	message: string;
 	filesChanged: number;
 }
 
 async function getCommitInfo(): Promise<CommitInfo> {
-	const [hash, timestampStr, branch, author, message, statText] = await Promise.all([
+	const [hash, timestampStr, branch, author, authorEmail, message, statText] = await Promise.all([
 		git("rev-parse", "HEAD"),
 		git("log", "-1", "--format=%at"),
 		git("rev-parse", "--abbrev-ref", "HEAD"),
 		git("log", "-1", "--format=%an"),
+		git("log", "-1", "--format=%ae"),
 		git("log", "-1", "--format=%s"),
 		git("diff", "--stat", "HEAD~1..HEAD").catch(() => git("diff", "--stat", "--root", "HEAD")),
 	]);
@@ -137,6 +140,7 @@ async function getCommitInfo(): Promise<CommitInfo> {
 		timestamp: parseInt(timestampStr) * 1000,
 		branch,
 		author,
+		authorEmail,
 		message,
 		filesChanged,
 	};
@@ -148,13 +152,6 @@ function isProjectMatch(session: SessionMeta, repoRoot: string, repoName: string
 	return sp === rp || sp.startsWith(rp + "/") || session.projectName?.toLowerCase() === repoName.toLowerCase();
 }
 
-function findMatchingSessions(commitTimestamp: number, sessions: SessionMeta[]): SessionMeta[] {
-	const windowMs = WINDOW_MINUTES * 60 * 1000;
-	return sessions.filter((s) => {
-		return s.timeRange.start <= commitTimestamp + windowMs && s.timeRange.end >= commitTimestamp - windowMs;
-	});
-}
-
 /**
  * Resolve the exact Claude session active at commit time.
  *
@@ -287,7 +284,8 @@ async function run() {
 	const costUsd = Math.max(0, fullCost - prior.cost);
 	const messages = Math.max(0, fullMessages - prior.messages);
 
-	const record = {
+	const agentTool = detectAgentFromCommit(commit.authorEmail, commit.author);
+	const record: Record<string, unknown> = {
 		commit: commit.hash,
 		timestamp: new Date(commit.timestamp).toISOString(),
 		branch: commit.branch,
@@ -300,6 +298,7 @@ async function run() {
 		files_changed: commit.filesChanged,
 		_session_snapshot: { cost: fullCost, tokens: fullTokens, messages: fullMessages },
 	};
+	if (agentTool) record.ai_tool = agentTool;
 
 	await Bun.write(trackingPath, existingContent + JSON.stringify(record) + "\n");
 }
@@ -308,7 +307,7 @@ async function run() {
 
 async function getCommitHistory(opts: { from?: string; to?: string } = {}): Promise<CommitInfo[]> {
 	const since = opts.from ?? new Date(Date.now() - 30 * 86400000).toISOString().slice(0, 10);
-	const args = ["log", "--all", `--since=${since}`, "--format=%H\t%an\t%aI\t%at\t%s", "--shortstat"];
+	const args = ["log", "--all", `--since=${since}`, "--format=%H\t%an\t%ae\t%aI\t%at\t%s", "--shortstat"];
 	if (opts.to) args.push(`--until=${opts.to}`);
 
 	const proc = Bun.spawn(["git", ...args], { stdout: "pipe", stderr: "pipe" });
@@ -324,9 +323,9 @@ async function getCommitHistory(opts: { from?: string; to?: string } = {}): Prom
 		if (!line || !line.includes("\t")) continue;
 
 		const parts = line.split("\t");
-		if (parts.length < 5) continue;
+		if (parts.length < 6) continue;
 
-		const [hash, author, , timestamp, message] = parts;
+		const [hash, author, authorEmail, , timestamp, message] = parts;
 
 		let filesChanged = 0;
 		// --shortstat puts a blank line between format and stat lines
@@ -346,6 +345,7 @@ async function getCommitHistory(opts: { from?: string; to?: string } = {}): Prom
 			timestamp: parseInt(timestamp) * 1000,
 			branch: "unknown",
 			author,
+			authorEmail,
 			message,
 			filesChanged,
 		});
@@ -353,21 +353,9 @@ async function getCommitHistory(opts: { from?: string; to?: string } = {}): Prom
 
 	// Resolve per-commit branch in one batched git name-rev call (~18ms for 34 commits).
 	// git log --format=%D only decorates ~9% of commits (branch tips); name-rev covers 100%.
-	if (fullHashes.length > 0) {
-		const nr = Bun.spawn(["git", "name-rev", "--always", "--exclude=HEAD", ...fullHashes], { stdout: "pipe", stderr: "pipe" });
-		const nrText = await new Response(nr.stdout).text();
-		await nr.exited;
-		const refMap = new Map<string, string>();
-		for (const line of nrText.trim().split("\n")) {
-			const [h, ref] = line.trim().split(/\s+/);
-			if (h && ref) {
-				const base = ref.split(/[~^]/)[0]; // strip ~1, ^2 ancestor notation
-				refMap.set(h, base.replace(/^remotes\/origin\//, "").replace(/^remotes\//, ""));
-			}
-		}
-		for (let i = 0; i < commits.length; i++) {
-			commits[i].branch = refMap.get(fullHashes[i]) ?? "unknown";
-		}
+	const refMap = await resolveCommitBranches(fullHashes);
+	for (let i = 0; i < commits.length; i++) {
+		commits[i].branch = refMap.get(fullHashes[i]) ?? "unknown";
 	}
 
 	return commits;
@@ -411,7 +399,7 @@ async function init(opts: { from?: string; to?: string } = {}) {
 	const commitMatches = new Map<string, SessionMeta[]>();
 	for (const commit of commits) {
 		if (existingHashes.has(commit.hash)) continue;
-		const matched = findMatchingSessions(commit.timestamp, projectSessions);
+		const matched = findMatchingSessions(commit.timestamp, commit.branch, projectSessions, WINDOW_MINUTES * 60 * 1000);
 		if (matched.length === 0) continue;
 		commitMatches.set(commit.hash, matched);
 		for (const s of matched) {
@@ -454,7 +442,8 @@ async function init(opts: { from?: string; to?: string } = {}) {
 			return sum + estimateCost(s) / share;
 		}, 0);
 
-		newRecords.push(JSON.stringify({
+		const agentTool = detectAgentFromCommit(commit.authorEmail, commit.author);
+		const initRecord: Record<string, unknown> = {
 			commit: commit.hash,
 			timestamp: new Date(commit.timestamp).toISOString(),
 			branch: commit.branch,
@@ -465,7 +454,9 @@ async function init(opts: { from?: string; to?: string } = {}) {
 			models: [...models],
 			messages,
 			files_changed: commit.filesChanged,
-		}));
+		};
+		if (agentTool) initRecord.ai_tool = agentTool;
+		newRecords.push(JSON.stringify(initRecord));
 	}
 
 	// Append all new records at once

package/examples/cost-per-feature.ts

@@ -10,6 +10,7 @@
  */
 
 import { createHistory, estimateCost, type SessionMeta } from "../src/index.js";
+import { fmtTokens } from "./git-helpers.js";
 
 const args = process.argv.slice(2);
 function getArg(name: string): string | undefined {
@@ -173,7 +174,7 @@ async function main() {
 			console.log(
 				("    " + f.branch.slice(0, 30)).padEnd(35),
 				String(f.sessions).padStart(10),
-				formatTokens(tokens).padStart(12),
+				fmtTokens(tokens).padStart(12),
 				`$${f.cost.toFixed(2)}`.padStart(12),
 				String(f.commits).padStart(10),
 			);
@@ -185,7 +186,7 @@ async function main() {
 			console.log(
 				"    (no branch)".padEnd(35),
 				String(pg.unmatched.length).padStart(10),
-				formatTokens(tokens).padStart(12),
+				fmtTokens(tokens).padStart(12),
 				`$${unmatchedCost.toFixed(2)}`.padStart(12),
 				"-".padStart(10),
 			);
@@ -223,10 +224,4 @@ async function main() {
 	);
 }
 
-function formatTokens(n: number): string {
-	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-	if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
-	return String(n);
-}
-
 main().catch(console.error);

package/examples/git-helpers.ts

@@ -0,0 +1,66 @@
+/**
+ * git-helpers.ts — Shared git utilities for agent-optic examples.
+ */
+
+import type { SessionMeta } from "../src/index.js";
+
+/** Format a token count as a human-readable string (e.g. 21000 → "21K"). */
+export function fmtTokens(n: number): string {
+	if (n >= 1_000_000_000) return `${(n / 1_000_000_000).toFixed(1)}B`;
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(0)}K`;
+	return String(n);
+}
+
+/**
+ * Parse git name-rev output into a commit-hash → branch-name map.
+ * Resolves branch for every commit hash, covering 100% (vs ~9% from --format=%D).
+ * Returns "unknown" for any hash that couldn't be resolved.
+ */
+export async function resolveCommitBranches(
+	hashes: string[],
+	cwd?: string,
+): Promise<Map<string, string>> {
+	const refMap = new Map<string, string>();
+	if (hashes.length === 0) return refMap;
+
+	const nr = Bun.spawn(
+		["git", "name-rev", "--always", "--exclude=HEAD", ...hashes],
+		{ cwd, stdout: "pipe", stderr: "pipe" },
+	);
+	const nrText = await new Response(nr.stdout).text();
+	await nr.exited;
+
+	for (const line of nrText.trim().split("\n")) {
+		const [h, ref] = line.trim().split(/\s+/);
+		if (h && ref) {
+			const base = ref.split(/[~^]/)[0];
+			refMap.set(h, base.replace(/^remotes\/origin\//, "").replace(/^remotes\//, ""));
+		}
+	}
+	return refMap;
+}
+
+/**
+ * Find sessions active around a commit's timestamp.
+ * Prefers sessions on the same branch when branch info is available —
+ * eliminates false matches when multiple sessions run concurrently on different branches.
+ * Falls back to the full time-window set if no branch match is found.
+ */
+export function findMatchingSessions(
+	commitTimestamp: number,
+	commitBranch: string,
+	sessions: SessionMeta[],
+	windowMs: number,
+): SessionMeta[] {
+	const byTime = sessions.filter(
+		(s) => s.timeRange.start <= commitTimestamp + windowMs && s.timeRange.end >= commitTimestamp - windowMs,
+	);
+
+	if (commitBranch && commitBranch !== "unknown") {
+		const byBranch = byTime.filter((s) => s.gitBranch === commitBranch);
+		if (byBranch.length > 0) return byBranch;
+	}
+
+	return byTime;
+}

package/examples/match-git-commits.ts

@@ -11,6 +11,7 @@
  */
 
 import { createHistory, estimateCost, projectName, type SessionMeta } from "../src/index.js";
+import { resolveCommitBranches, findMatchingSessions } from "./git-helpers.js";
 import { resolve } from "node:path";
 
 const args = process.argv.slice(2);
@@ -29,6 +30,7 @@ interface GitCommit {
 	author: string;
 	date: string;
 	timestamp: number;
+	branch: string;
 	message: string;
 	filesChanged: number;
 }
@@ -43,6 +45,7 @@ async function getGitCommits(): Promise<GitCommit[]> {
 	await proc.exited;
 
 	const commits: GitCommit[] = [];
+	const fullHashes: string[] = [];
 	const lines = text.trim().split("\n");
 
 	for (let i = 0; i < lines.length; i++) {
@@ -66,24 +69,25 @@ async function getGitCommits(): Promise<GitCommit[]> {
 			}
 		}
 
+		fullHashes.push(hash);
 		commits.push({
 			hash: hash.slice(0, 8),
 			author,
 			date,
 			timestamp: parseInt(timestamp) * 1000,
+			branch: "unknown",
 			message: message.slice(0, 60),
 			filesChanged,
 		});
 	}
 
-	return commits;
-}
+	// git name-rev covers 100% of commits (vs ~9% from --format=%D)
+	const refMap = await resolveCommitBranches(fullHashes, repoPath);
+	for (let i = 0; i < commits.length; i++) {
+		commits[i].branch = refMap.get(fullHashes[i]) ?? "unknown";
+	}
 
-function findMatchingSessions(commit: GitCommit, sessions: SessionMeta[]): SessionMeta[] {
-	const windowMs = windowMinutes * 60 * 1000;
-	return sessions.filter((s) => {
-		return s.timeRange.start <= commit.timestamp + windowMs && s.timeRange.end >= commit.timestamp - windowMs;
-	});
+	return commits;
 }
 
 async function main() {
@@ -116,7 +120,7 @@ async function main() {
 
 	const sessionCommitCount = new Map<string, number>();
 	for (const commit of commits) {
-		for (const s of findMatchingSessions(commit, sessions)) {
+		for (const s of findMatchingSessions(commit.timestamp, commit.branch, sessions, windowMinutes * 60 * 1000)) {
 			sessionCommitCount.set(s.sessionId, (sessionCommitCount.get(s.sessionId) ?? 0) + 1);
 		}
 	}
@@ -138,7 +142,7 @@ async function main() {
 	let matchedCommits = 0;
 
 	for (const commit of commits) {
-		const matched = findMatchingSessions(commit, sessions);
+		const matched = findMatchingSessions(commit.timestamp, commit.branch, sessions, windowMinutes * 60 * 1000);
 
 		const cost = matched.reduce((sum, s) => {
 			const numCommits = sessionCommitCount.get(s.sessionId) ?? 1;

package/examples/model-costs.ts

@@ -9,6 +9,7 @@
  */
 
 import { createHistory, estimateCost, getModelPricing, type SessionMeta } from "../src/index.js";
+import { fmtTokens } from "./git-helpers.js";
 
 const args = process.argv.slice(2);
 function getArg(name: string, fallback: string): string {
@@ -19,11 +20,6 @@ function getArg(name: string, fallback: string): string {
 const from = getArg("--from", new Date(Date.now() - 30 * 86400000).toISOString().slice(0, 10));
 const to = getArg("--to", new Date().toISOString().slice(0, 10));
 
-function formatTokens(n: number): string {
-	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-	if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
-	return String(n);
-}
 
 function shortModel(model: string): string {
 	if (model.includes("opus")) return model.replace(/claude-/, "").slice(0, 20);
@@ -92,10 +88,10 @@ async function main() {
 		console.log(
 			shortModel(s.model).padEnd(24),
 			String(s.sessions).padStart(10),
-			formatTokens(s.inputTokens).padStart(10),
-			formatTokens(s.outputTokens).padStart(10),
-			formatTokens(s.cacheWriteTokens).padStart(10),
-			formatTokens(s.cacheReadTokens).padStart(10),
+			fmtTokens(s.inputTokens).padStart(10),
+			fmtTokens(s.outputTokens).padStart(10),
+			fmtTokens(s.cacheWriteTokens).padStart(10),
+			fmtTokens(s.cacheReadTokens).padStart(10),
 			`$${s.cost.toFixed(2)}`.padStart(12),
 		);
 	}
@@ -104,8 +100,8 @@ async function main() {
 	console.log(
 		"TOTAL".padEnd(24),
 		String(totalSessions).padStart(10),
-		formatTokens(totalInput).padStart(10),
-		formatTokens(totalOutput).padStart(10),
+		fmtTokens(totalInput).padStart(10),
+		fmtTokens(totalOutput).padStart(10),
 		"".padStart(10),
 		"".padStart(10),
 		`$${totalCost.toFixed(2)}`.padStart(12),
@@ -123,7 +119,7 @@ async function main() {
 		const avgCost = s.cost / s.sessions;
 		const avgTokens = (s.inputTokens + s.outputTokens) / s.sessions;
 		console.log(
-			`  ${shortModel(s.model).padEnd(24)} $${avgCost.toFixed(3)}/session  ${formatTokens(avgTokens)} tokens/session`,
+			`  ${shortModel(s.model).padEnd(24)} $${avgCost.toFixed(3)}/session  ${fmtTokens(avgTokens)} tokens/session`,
 		);
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "agent-optic",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"description": "Zero-dependency, local-first library for reading AI assistant session data from provider home directories",
 	"type": "module",
 	"exports": {
@@ -24,6 +24,7 @@
 		"codex",
 		"cursor",
 		"windsurf",
+		"copilot",
 		"session-history",
 		"developer-tools",
 		"productivity"

package/src/index.ts

@@ -38,4 +38,7 @@ export { toLocalDate, today } from "./utils/dates.js";
 
 // Pricing
 export type { ModelPricing } from "./pricing.js";
-export { MODEL_PRICING, getModelPricing, estimateCost, setPricing } from "./pricing.js";
+export { MODEL_PRICING, getModelPricing, normalizeModelName, estimateCost, setPricing } from "./pricing.js";
+
+// Provider utilities
+export { detectAgentFromCommit, AGENT_COMMIT_EMAILS, AGENT_COMMIT_USERNAMES } from "./utils/providers.js";

package/src/parsers/session-detail.ts

@@ -14,6 +14,7 @@ import {
 	parseCodexToolArguments,
 } from "../readers/codex-rollout-reader.js";
 import { parsePiSessionDetail } from "../readers/pi-session-reader.js";
+import { parseCopilotSessionDetail } from "../readers/copilot-session-reader.js";
 
 /**
  * Parse a full session JSONL file into a SessionDetail.
@@ -29,6 +30,9 @@ export async function parseSessionDetail(
 	if (normalized === "pi") {
 		return parsePiSessionDetail(session, paths.sessionsDir, privacy);
 	}
+	if (normalized === "copilot") {
+		return parseCopilotSessionDetail(session, paths.sessionsDir, privacy);
+	}
 	if (normalized === "codex") {
 		return parseCodexSessionDetail(session, paths.sessionsDir, privacy);
 	}

package/src/pricing.ts

@@ -10,15 +10,20 @@ export interface ModelPricing {
 
 /** Default model pricing (USD per million tokens). */
 export const MODEL_PRICING: Record<string, ModelPricing> = {
-	// Opus 4.5+ ($5/$25)
+	// Opus 4.6 ($5/$25)
 	"claude-opus-4-6": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+
+	// Sonnet 4.6 ($3/$15)
+	"claude-sonnet-4-6": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+
+	// Opus 4.5 ($5/$25)
 	"claude-opus-4-5-20250514": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
 
 	// Opus 4.0–4.1 ($15/$75)
 	"claude-opus-4-1-20250514": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
 	"claude-opus-4-0-20250514": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
 
-	// Sonnet ($3/$15)
+	// Sonnet 4.5 ($3/$15)
 	"claude-sonnet-4-5-20250929": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
 	"claude-sonnet-4-5-20250514": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
 	"claude-sonnet-4-0-20250514": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
@@ -37,16 +42,73 @@ export const MODEL_PRICING: Record<string, ModelPricing> = {
 const FALLBACK_PRICING: ModelPricing = { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 };
 
 let activePricing: Record<string, ModelPricing> = MODEL_PRICING;
+// Pre-normalized key map; rebuilt when activePricing changes
+let normalizedPricingKeys: Map<string, ModelPricing> | null = null;
+
+function getNormalizedPricingKeys(): Map<string, ModelPricing> {
+	if (!normalizedPricingKeys) {
+		normalizedPricingKeys = new Map(
+			Object.entries(activePricing).map(([k, v]) => [normalizeModelName(k), v]),
+		);
+	}
+	return normalizedPricingKeys;
+}
 
 /** Override or extend the pricing table. Merges with built-in defaults. */
 export function setPricing(overrides: Record<string, ModelPricing>): void {
 	activePricing = { ...MODEL_PRICING, ...overrides };
+	normalizedPricingKeys = null;
 }
 
-/** Look up pricing for a model, falling back to Sonnet rates. */
+/**
+ * Normalize a model name for pricing lookup.
+ * Strips provider prefixes, date suffixes, and qualifiers so that
+ * "anthropic/claude-sonnet-4-6-20260101:thinking" resolves to "claude-sonnet-4-6".
+ * Normalization approach inspired by agentlytics.
+ */
+export function normalizeModelName(model: string): string {
+	let name = model.trim().toLowerCase();
+	// Strip provider prefixes: anthropic/, anthropic., aws/, bedrock/, us.anthropic.
+	name = name.replace(/^(?:anthropic|aws|bedrock)[./]|^us\.anthropic[./]/, "");
+	// Strip qualifier suffixes: :thinking, :preview, :latest, -preview, -latest, -fast, -turbo
+	name = name.replace(/(?::(?:thinking|preview|latest)|-(?:preview|latest|fast|turbo))$/, "");
+	// Strip 8-digit date suffix (YYYYMMDD)
+	name = name.replace(/-\d{8}$/, "");
+	// Normalize dots in version numbers to dashes (e.g. "claude-opus-4.6" → "claude-opus-4-6")
+	name = name.replace(/(\w)\.(\d)/g, "$1-$2");
+	return name;
+}
+
+/**
+ * Look up pricing for a model, falling back to Sonnet rates.
+ * Resolution order:
+ *   1. Exact match
+ *   2. Normalized exact match (strip prefix/date/qualifiers)
+ *   3. Longest normalized prefix match (future model variants)
+ */
 export function getModelPricing(model?: string): ModelPricing {
 	if (!model) return FALLBACK_PRICING;
-	return activePricing[model] ?? FALLBACK_PRICING;
+
+	// 1. Exact match
+	if (activePricing[model]) return activePricing[model];
+
+	// 2. Normalized exact match
+	const norm = normalizeModelName(model);
+	const normMap = getNormalizedPricingKeys();
+	const exact = normMap.get(norm);
+	if (exact) return exact;
+
+	// 3. Longest normalized prefix match
+	// e.g. incoming "claude-sonnet-4-5" matches table key "claude-sonnet-4-5-20250929"
+	let best: ModelPricing | undefined;
+	let bestLen = 0;
+	for (const [normKey, pricing] of normMap) {
+		if (norm.startsWith(normKey) && normKey.length > bestLen) {
+			best = pricing;
+			bestLen = normKey.length;
+		}
+	}
+	return best ?? FALLBACK_PRICING;
 }
 
 /** Estimate USD cost of a session based on token counts and model. */

package/src/readers/copilot-session-reader.ts

@@ -0,0 +1,432 @@
+import { join } from "node:path";
+import type { PrivacyConfig } from "../types/privacy.js";
+import type { SessionDetail, SessionInfo, SessionMeta, ToolCallSummary } from "../types/session.js";
+import type { ContentBlock, TranscriptEntry } from "../types/transcript.js";
+import { projectName } from "../utils/paths.js";
+import { toLocalDate } from "../utils/dates.js";
+import { isProjectExcluded, redactString, filterTranscriptEntry } from "../privacy/redact.js";
+import { categorizeToolName, toolDisplayName } from "../parsers/tool-categories.js";
+
+// Copilot CLI session layout:
+//   ~/.copilot/session-state/{uuid}/workspace.yaml  — always present, metadata
+//   ~/.copilot/session-state/{uuid}/events.jsonl    — present only when session had interactions
+//
+// workspace.yaml keys: id, cwd, branch, summary, created_at, updated_at, git_root, repository
+
+/** Parse simple flat YAML (key: value lines). No library required. */
+function parseSimpleYaml(text: string): Record<string, string> {
+	const result: Record<string, string> = {};
+	for (const line of text.split("\n")) {
+		const colonIdx = line.indexOf(":");
+		if (colonIdx === -1) continue;
+		const key = line.slice(0, colonIdx).trim();
+		const value = line.slice(colonIdx + 1).trim();
+		if (key && value) result[key] = value;
+	}
+	return result;
+}
+
+function eventsPath(sessionsDir: string, sessionId: string): string {
+	return join(sessionsDir, sessionId, "events.jsonl");
+}
+
+function workspacePath(sessionsDir: string, sessionId: string): string {
+	return join(sessionsDir, sessionId, "workspace.yaml");
+}
+
+function accumulateCopilotTokens(
+	metrics: unknown,
+	target: { totalInputTokens: number; totalOutputTokens: number; cacheReadInputTokens: number; cacheCreationInputTokens: number },
+): void {
+	if (!metrics || typeof metrics !== "object") return;
+	for (const modelStats of Object.values(metrics) as any[]) {
+		const usage = modelStats?.usage;
+		if (!usage) continue;
+		target.totalInputTokens += Number(usage.inputTokens ?? 0);
+		target.totalOutputTokens += Number(usage.outputTokens ?? 0);
+		target.cacheReadInputTokens += Number(usage.cacheReadTokens ?? 0);
+		target.cacheCreationInputTokens += Number(usage.cacheWriteTokens ?? 0);
+	}
+}
+
+async function readCopilotBranch(session: SessionInfo, sessionsDir: string): Promise<string | undefined> {
+	if ((session as SessionMeta).gitBranch) return (session as SessionMeta).gitBranch;
+	const wsFile = Bun.file(workspacePath(sessionsDir, session.sessionId));
+	if (!(await wsFile.exists())) return undefined;
+	try {
+		const ws = parseSimpleYaml(await wsFile.text());
+		if (ws.branch && ws.branch !== "HEAD") return ws.branch;
+	} catch {}
+	return undefined;
+}
+
+function parseTs(ts: unknown): number {
+	if (typeof ts === "number") return ts;
+	if (typeof ts === "string") {
+		const n = new Date(ts).getTime();
+		return isNaN(n) ? 0 : n;
+	}
+	return 0;
+}
+
+/** Read all Copilot CLI sessions by scanning session-state/ (no history.jsonl). */
+export async function readCopilotHistory(
+	sessionsDir: string,
+	from: string,
+	to: string,
+	privacy: PrivacyConfig,
+): Promise<SessionInfo[]> {
+	const sessions: SessionInfo[] = [];
+	const glob = new Bun.Glob("*/workspace.yaml");
+
+	for await (const relPath of glob.scan({ cwd: sessionsDir, absolute: false })) {
+		const sessionId = relPath.split("/")[0];
+		const wsFile = Bun.file(join(sessionsDir, relPath));
+		if (!(await wsFile.exists())) continue;
+
+		let ws: Record<string, string>;
+		try {
+			ws = parseSimpleYaml(await wsFile.text());
+		} catch {
+			continue;
+		}
+
+		const cwd = ws.cwd;
+		const branch = ws.branch;
+		const startTime = parseTs(ws.created_at);
+		if (!cwd || !startTime) continue;
+
+		const startDate = toLocalDate(startTime);
+		if (startDate < from || startDate > to) continue;
+		if (isProjectExcluded(cwd, privacy)) continue;
+
+		// Try to get first user prompt from events.jsonl (best-effort, skip if absent)
+		let firstPrompt: string | undefined;
+		let endTime = startTime;
+		const evFile = Bun.file(eventsPath(sessionsDir, sessionId));
+		if (await evFile.exists()) {
+			try {
+				const text = await evFile.text();
+				for (const line of text.split("\n")) {
+					if (!line.trim()) continue;
+					let entry: any;
+					try { entry = JSON.parse(line); } catch { continue; }
+
+					const ts = parseTs(entry.timestamp);
+					if (ts > endTime) endTime = ts;
+
+					if (entry.type === "user.message" && !firstPrompt) {
+						const content = entry.data?.content;
+						if (typeof content === "string" && content.trim()) firstPrompt = content;
+					}
+				}
+			} catch {
+				// events.jsonl unreadable — use workspace summary as fallback
+			}
+		}
+
+		// Fall back to workspace summary for sessions without events
+		if (!firstPrompt && ws.summary) firstPrompt = ws.summary;
+
+		const prompt = firstPrompt
+			? privacy.redactPrompts
+				? "[redacted]"
+				: privacy.redactPatterns.length > 0
+					? redactString(firstPrompt, privacy)
+					: firstPrompt
+			: "(no prompt)";
+
+		const session: SessionInfo = {
+			sessionId,
+			project: cwd,
+			projectName: projectName(cwd),
+			prompts: [prompt],
+			promptTimestamps: [startTime],
+			timeRange: { start: startTime, end: endTime },
+		};
+
+		if (branch && branch !== "HEAD") {
+			(session as SessionMeta).gitBranch = branch;
+		}
+
+		sessions.push(session);
+	}
+
+	sessions.sort((a, b) => a.timeRange.start - b.timeRange.start);
+	return sessions;
+}
+
+/** Peek Copilot session metadata (model, tokens, branch). */
+export async function peekCopilotSession(
+	session: SessionInfo,
+	sessionsDir: string,
+): Promise<SessionMeta> {
+	const meta: SessionMeta = {
+		...session,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheReadInputTokens: 0,
+		messageCount: 0,
+	};
+
+	meta.gitBranch = await readCopilotBranch(session, sessionsDir);
+
+	const file = Bun.file(eventsPath(sessionsDir, session.sessionId));
+	if (!(await file.exists())) return meta;
+
+	try {
+		const text = await file.text();
+		for (const line of text.split("\n")) {
+			if (!line.trim()) continue;
+			let entry: any;
+			try { entry = JSON.parse(line); } catch { continue; }
+
+			if (entry.type === "session.model_change" && !meta.model) {
+				const model = entry.data?.newModel;
+				if (typeof model === "string") meta.model = model;
+			}
+
+			if (entry.type === "user.message") meta.messageCount++;
+			if (entry.type === "assistant.message") meta.messageCount++;
+
+			// session.shutdown carries accurate cumulative token totals per model
+			if (entry.type === "session.shutdown") {
+				accumulateCopilotTokens(entry.data?.modelMetrics, meta);
+				if (!meta.model) {
+					const current = entry.data?.currentModel;
+					if (typeof current === "string") meta.model = current;
+				}
+			}
+		}
+	} catch {
+		// file unreadable
+	}
+
+	return meta;
+}
+
+/** Parse full Copilot session detail. */
+export async function parseCopilotSessionDetail(
+	session: SessionInfo,
+	sessionsDir: string,
+	privacy: PrivacyConfig,
+): Promise<SessionDetail> {
+	const detail: SessionDetail = {
+		...session,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheReadInputTokens: 0,
+		messageCount: 0,
+		assistantSummaries: [],
+		toolCalls: [],
+		filesReferenced: [],
+		planReferenced: false,
+		thinkingBlockCount: 0,
+		hasSidechains: false,
+	};
+
+	detail.gitBranch = await readCopilotBranch(session, sessionsDir);
+
+	const file = Bun.file(eventsPath(sessionsDir, session.sessionId));
+	if (!(await file.exists())) return detail;
+
+	const toolCallSet = new Map<string, ToolCallSummary>();
+	const fileSet = new Set<string>();
+	let model: string | undefined;
+
+	try {
+		const text = await file.text();
+		for (const line of text.split("\n")) {
+			if (!line.trim()) continue;
+			let entry: any;
+			try { entry = JSON.parse(line); } catch { continue; }
+
+			if (entry.type === "session.model_change" && !model) {
+				const m = entry.data?.newModel;
+				if (typeof m === "string") model = m;
+			}
+
+			if (entry.type === "session.shutdown") {
+				accumulateCopilotTokens(entry.data?.modelMetrics, detail);
+				if (!model) {
+					const current = entry.data?.currentModel;
+					if (typeof current === "string") model = current;
+				}
+			}
+
+			if (entry.type === "user.message") {
+				detail.messageCount++;
+			}
+
+			if (entry.type === "assistant.message") {
+				detail.messageCount++;
+
+				// Count thinking block
+				if (typeof entry.data?.reasoningText === "string" && entry.data.reasoningText) {
+					detail.thinkingBlockCount++;
+				}
+
+				const textContent = entry.data?.content;
+				if (typeof textContent === "string" && textContent.length > 20) {
+					const redacted =
+						privacy.redactPatterns.length > 0 || privacy.redactHomeDir
+							? redactString(textContent, privacy)
+							: textContent;
+					detail.assistantSummaries.push(
+						redacted.slice(0, 200) + (redacted.length > 200 ? "..." : ""),
+					);
+				}
+
+				const toolRequests = entry.data?.toolRequests;
+				if (Array.isArray(toolRequests)) {
+					for (const req of toolRequests) {
+						const name = req.name ?? req.toolName;
+						if (typeof name !== "string") continue;
+						const input =
+							req.arguments && typeof req.arguments === "object"
+								? req.arguments
+								: undefined;
+						const displayName = toolDisplayName(name, input);
+						toolCallSet.set(displayName, {
+							name,
+							displayName,
+							category: categorizeToolName(name),
+							target: extractToolTarget(name, input),
+						});
+						const fp = extractFilePath(input);
+						if (fp) fileSet.add(fp);
+					}
+				}
+			}
+		}
+	} catch {
+		// file unreadable
+	}
+
+	detail.toolCalls = [...toolCallSet.values()];
+	detail.filesReferenced = [...fileSet];
+	detail.model = model;
+	detail.assistantSummaries = detail.assistantSummaries.slice(0, 10);
+	return detail;
+}
+
+/** Stream Copilot transcript entries with privacy filtering. */
+export async function* streamCopilotTranscript(
+	sessionId: string,
+	sessionsDir: string,
+	privacy: PrivacyConfig,
+): AsyncGenerator<TranscriptEntry> {
+	const file = Bun.file(eventsPath(sessionsDir, sessionId));
+	if (!(await file.exists())) return;
+
+	let currentModel: string | undefined;
+
+	const text = await file.text();
+	for (const line of text.split("\n")) {
+		if (!line.trim()) continue;
+		let raw: any;
+		try { raw = JSON.parse(line); } catch { continue; }
+
+		if (raw.type === "session.model_change") {
+			const m = raw.data?.newModel;
+			if (typeof m === "string") currentModel = m;
+			continue;
+		}
+
+		let mapped: TranscriptEntry | null = null;
+		const ts = parseTs(raw.timestamp);
+		const tsIso = ts ? new Date(ts).toISOString() : undefined;
+
+		if (raw.type === "user.message") {
+			const content = raw.data?.content;
+			mapped = {
+				timestamp: tsIso,
+				message: {
+					role: "user",
+					content: typeof content === "string" ? content : "",
+				},
+			};
+		} else if (raw.type === "assistant.message") {
+			const blocks: ContentBlock[] = [];
+
+			if (typeof raw.data?.reasoningText === "string" && raw.data.reasoningText) {
+				blocks.push({ type: "thinking", thinking: raw.data.reasoningText });
+			}
+
+			const textContent = raw.data?.content;
+			if (typeof textContent === "string" && textContent) {
+				blocks.push({ type: "text", text: textContent });
+			}
+
+			const toolRequests = raw.data?.toolRequests;
+			if (Array.isArray(toolRequests)) {
+				for (const req of toolRequests) {
+					const name = req.name ?? req.toolName;
+					if (typeof name === "string") {
+						blocks.push({
+							type: "tool_use",
+							name,
+							id: req.toolCallId,
+							input:
+								req.arguments && typeof req.arguments === "object"
+									? req.arguments
+									: undefined,
+						});
+					}
+				}
+			}
+
+			mapped = {
+				timestamp: tsIso,
+				message: {
+					role: "assistant",
+					model: currentModel,
+					content: blocks,
+				},
+			};
+		} else if (raw.type === "tool.execution_complete") {
+			const result = raw.data?.result;
+			const output =
+				typeof result?.content === "string"
+					? result.content
+					: typeof result?.detailedContent === "string"
+						? result.detailedContent
+						: undefined;
+			mapped = {
+				timestamp: tsIso,
+				toolUseResult: output,
+			};
+		}
+
+		if (!mapped) continue;
+		const filtered = filterTranscriptEntry(mapped, privacy);
+		if (filtered) yield filtered;
+	}
+}
+
+function extractFilePath(input: Record<string, unknown> | undefined): string | undefined {
+	if (!input) return undefined;
+	for (const key of ["file_path", "path", "target_file", "filename"]) {
+		const value = input[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+function extractToolTarget(
+	_name: string,
+	input: Record<string, unknown> | undefined,
+): string | undefined {
+	const fp = extractFilePath(input);
+	if (fp) return fp;
+	if (!input) return undefined;
+	for (const key of ["command", "pattern", "query"]) {
+		const value = input[key];
+		if (typeof value === "string" && value.length > 0) {
+			return key === "command" ? value.split(" ")[0] : value;
+		}
+	}
+	return undefined;
+}

package/src/readers/history-reader.ts

@@ -8,6 +8,7 @@ import { canonicalProvider } from "../utils/providers.js";
 import { isProjectExcluded, redactString } from "../privacy/redact.js";
 import { readCodexSessionHeader } from "./codex-rollout-reader.js";
 import { readPiHistory } from "./pi-session-reader.js";
+import { readCopilotHistory } from "./copilot-session-reader.js";
 
 interface ClaudeHistoryEntry {
 	display: string;
@@ -44,6 +45,12 @@ export async function readHistory(
 			from, to, privacy,
 		);
 	}
+	if (provider === "copilot") {
+		return readCopilotHistory(
+			options?.sessionsDir ?? join(dirname(historyFile), "session-state"),
+			from, to, privacy,
+		);
+	}
 	if (provider === "codex") {
 		return readCodexHistory(
 			historyFile,

package/src/readers/session-reader.ts

@@ -12,6 +12,7 @@ import {
 	parseCodexToolArguments,
 } from "./codex-rollout-reader.js";
 import { peekPiSession, streamPiTranscript } from "./pi-session-reader.js";
+import { peekCopilotSession, streamCopilotTranscript } from "./copilot-session-reader.js";
 
 /**
  * Peek session metadata from a session JSONL file.
@@ -28,6 +29,9 @@ export async function peekSession(
 	if (normalized === "pi") {
 		return peekPiSession(session, paths.sessionsDir);
 	}
+	if (normalized === "copilot") {
+		return peekCopilotSession(session, paths.sessionsDir);
+	}
 	if (normalized === "codex") {
 		return peekCodexSession(session, paths.sessionsDir);
 	}
@@ -181,6 +185,10 @@ export async function* streamTranscript(
 		yield* streamPiTranscript(sessionId, paths.sessionsDir, privacy);
 		return;
 	}
+	if (normalized === "copilot") {
+		yield* streamCopilotTranscript(sessionId, paths.sessionsDir, privacy);
+		return;
+	}
 	if (normalized === "codex") {
 		yield* streamCodexTranscript(sessionId, paths.sessionsDir, privacy);
 		return;

package/src/types/provider.ts

@@ -5,6 +5,7 @@ export const SUPPORTED_PROVIDERS = [
 	"cursor",
 	"windsurf",
 	"pi",
+	"copilot",
 ] as const;
 
 export type Provider = (typeof SUPPORTED_PROVIDERS)[number];

package/src/utils/paths.ts

@@ -54,6 +54,21 @@ export function providerPaths(config?: {
 		};
 	}
 
+	if (provider === "copilot") {
+		return {
+			base,
+			historyFile: join(base, "history.jsonl"), // Copilot has no history.jsonl — unused
+			projectsDir: join(base, "session-state"),
+			sessionsDir: join(base, "session-state"),
+			globalStateFile: join(base, "global-state.json"),
+			tasksDir: join(base, "tasks"),
+			plansDir: join(base, "plans"),
+			todosDir: join(base, "todos"),
+			skillsDir: join(base, "skills"),
+			statsCache: join(base, "stats-cache.json"),
+		};
+	}
+
 	return {
 		base,
 		historyFile: join(base, "history.jsonl"),

package/src/utils/providers.ts

@@ -9,6 +9,7 @@ const PROVIDER_HOME_DIR: Record<Provider, string> = {
 	cursor: ".cursor",
 	windsurf: ".windsurf",
 	pi: ".pi",
+	copilot: ".copilot",
 };
 
 export const DEFAULT_PROVIDER: Provider = "claude";
@@ -25,3 +26,38 @@ export function canonicalProvider(provider: Provider): Exclude<Provider, "openai
 	if (provider === "openai") return "codex";
 	return provider;
 }
+
+/**
+ * Known AI agent commit emails and usernames.
+ * Used to attribute commits from fully-automated agents (Cursor, Copilot SWE, Devin)
+ * that lack a local session file. Sourced from git-ai's agent_detection.rs.
+ */
+export const AGENT_COMMIT_EMAILS: Record<string, string> = {
+	"cursoragent@cursor.com": "cursor",
+	"198982749+copilot@users.noreply.github.com": "github-copilot",
+	"158243242+devin-ai-integration[bot]@users.noreply.github.com": "devin",
+	"noreply@anthropic.com": "claude",
+	"noreply@openai.com": "codex",
+};
+
+export const AGENT_COMMIT_USERNAMES: Record<string, string> = {
+	"copilot-swe-agent[bot]": "github-copilot",
+	"devin-ai-integration[bot]": "devin",
+	"cursor[bot]": "cursor",
+};
+
+/**
+ * Detect the AI tool that authored a commit based on its git author email or username.
+ * Returns the tool name (e.g. "cursor", "github-copilot") or undefined if not a known agent.
+ */
+export function detectAgentFromCommit(email?: string, username?: string): string | undefined {
+	if (email) {
+		const byEmail = AGENT_COMMIT_EMAILS[email.toLowerCase()];
+		if (byEmail) return byEmail;
+	}
+	if (username) {
+		const byUsername = AGENT_COMMIT_USERNAMES[username.toLowerCase()];
+		if (byUsername) return byUsername;
+	}
+	return undefined;
+}