claude-attribution 1.8.0 → 1.9.0

package/README.md

@@ -1,12 +1,12 @@
 # claude-attribution
 
-AI code attribution for Claude Code. After every `git commit`, a one-line summary appears in your terminal:
+AI code attribution for Claude Code and GitHub Copilot. After every `git commit`, a one-line summary appears in your terminal:
 
 ```
 [claude-attribution] a3f1b2c — 142 AI / 38 human / 4 mixed lines (77% AI)
 ```
 
-When a PR is opened, full metrics — model usage, token counts, tool calls, and attribution percentages — are injected automatically into the PR body. No copy-paste, no manual tracking.
+When a PR is opened, full metrics — model usage, token counts when available, tool calls, and attribution percentages — are injected automatically into the PR body. No copy-paste, no manual tracking.
 
 **Quick start:**
 
@@ -19,13 +19,13 @@ git commit -m "chore: install claude-attribution hooks"
 git push
 ```
 
-**Using Copilot or `@claude` (claude-code-action)?** Bot commits are auto-detected and attributed as 100% AI — no extra steps needed. See [AI Actor Attribution](#ai-actor-attribution-copilot-bot-claude-gha).
+**Using Copilot or `@claude` (claude-code-action)?** Local Copilot CLI sessions are parsed from `~/.copilot/session-state/...`, and bot commits are auto-detected as 100% AI when no local session data exists. See [Copilot CLI Support](#copilot-cli-support) and [AI Actor Attribution](#ai-actor-attribution-copilot-bot-claude-gha).
 
 **Requirements:** [Bun](https://bun.sh) (preferred) or Node 18+, and `gh` (GitHub CLI) authenticated for the `/pr` command.
 
 ---
 
-Measures which lines in a commit were written by Claude vs. a human — using checkpoint snapshots and line-level SHA-256 comparison, not gross write-operation counts.
+Measures which lines in a commit were written by an AI assistant vs. a human — using checkpoint snapshots and line-level SHA-256 comparison when available, with explicit fallbacks for Copilot CLI sessions and hosted AI bot commits.
 
 ---
 
@@ -188,7 +188,7 @@ If you reinstall `claude-attribution` globally (e.g. after upgrading), you can n
 claude-attribution update
 ```
 
-The installer records each repo in a per-user registry at `~/.claude/claude-attribution/installed-repos.json`. `update` re-runs the installer for every still-valid tracked repo, skips repos already on the current CLI version, and prunes paths that no longer exist or are no longer git repos.
+The installer records each repo installed with `claude-attribution` v1.8.0 or later in a per-user registry at `~/.claude/claude-attribution/installed-repos.json`. `update` re-runs the installer for every still-valid tracked repo in that registry, skips repos already on the current CLI version, and prunes paths that no longer exist or are no longer git repos. Repos installed before v1.8.0 will not appear there until you run `claude-attribution install` for them once on the newer CLI.
 
 To force a reinstall even when the recorded version already matches, use:
 
@@ -242,33 +242,41 @@ Metrics are injected automatically — no command needed.
 
 **When Claude creates the PR** (asks Claude to open a PR, uses `/pr`): the `post-bash` hook fires immediately after `gh pr create` succeeds, injects full local metrics (token usage, tool counts, attribution) into the PR body before Claude continues.
 
-**When you create the PR yourself** (`gh pr create`, GitHub UI, Copilot): the `claude-attribution-pr.yml` GitHub Actions workflow fires on `opened` and injects attribution-only metrics (token counts aren't available in CI since logs are local).
+**When you create the PR yourself** (`gh pr create`, GitHub UI, Copilot): the `claude-attribution-pr.yml` GitHub Actions workflow fires on `opened` and rebuilds metrics from durable git notes when available. If only CI-visible data exists, it falls back to attribution-only metrics because local session logs are not available in CI.
 
 **On every new push to an open PR**: the workflow fires on `synchronize` and updates the attribution percentages to reflect new commits.
 
 The metrics block injected into the PR body looks like (when the cumulative minimap exists):
 
-> ## Claude Code Metrics
+> ## AI Coding Metrics
 >
 > **Codebase: ~77% AI** (3200 / 4150 lines)
-> **This PR:** 184 lines changed (4% of codebase) · 77% Claude edits · 142 AI lines · Active: 8m
+> **This PR:** 184 lines changed (4% of codebase) · 77% AI edits · 142 AI lines
+> **Session:** 12 prompts · 24m total (18m AI · 6m human)
+> **Assistant runtime:** Claude Code (claude-sonnet-4-6)
 >
 > | Model | Calls | Input | Output | Cache |
 > |-------|-------|-------|--------|-------|
 > | Sonnet | 45 | 120K | 35K | 10K |
 > | **Total** | 45 | 120K | 35K | 10K |
 >
-> **Human prompts (steering effort):** 12
+> **Estimated cost:** ~$1.23
 >
 > <details><summary>Tools · Agents · Files</summary>
 >
-> **Tools:** Edit ×47, Read ×31, Bash ×12
+> **External tools:** WebSearch ×2
 >
 > </details>
 
 Before running `init --ai` (or on a fresh install with no minimap), the headline falls back to the session-only view:
 
-> **AI contribution: ~77%** (142 of 184 committed lines) · Active: 8m
+> **AI contribution: ~77%** (142 of 184 committed lines)
+
+For **Copilot CLI** sessions, the same block is rendered with provider-aware differences:
+
+- assistant runtime shows as `GitHub Copilot CLI`
+- model usage shows **Known Tokens** instead of Claude-style input/output/cache columns
+- cost is shown as **unavailable** unless durable local billing data exists
 
 The block is wrapped in HTML comments for idempotent updates — re-running replaces the existing block rather than appending:
 
@@ -301,31 +309,19 @@ claude-attribution metrics
 The output is markdown you paste into your PR description:
 
 ```markdown
-## Claude Code Metrics
-
-**Session ID:** `abc-123-...`
-
-### Tools Used
-- **Edit:** 47 calls
-- **Read:** 31 calls
-...
+## AI Coding Metrics
 
-### Model Usage
-| Model | API Calls | Input Tokens | Output Tokens | Cache Tokens |
-...
+**Codebase: ~77% AI** (3200 / 4150 lines)
+**This PR:** 184 lines changed (4% of codebase) · 77% AI edits · 142 AI lines
+**Session:** 12 prompts · 24m total (18m AI · 6m human)
+**Assistant runtime:** GitHub Copilot CLI (v1.0.15 · gpt-5.4)
 
-**Human prompts (steering effort):** 12
+| Model | Calls | Known Tokens |
+|-------|-------|--------------|
+| gpt-5.4 | 12 | 48K |
+| **Total** | 12 | 48K |
 
-### Code Attribution
-- **AI-authored lines:** 142
-- **Human-authored lines:** 38
-- **Mixed lines (AI wrote, human modified):** 4
-- **Total committed lines:** 184
-- **AI contribution:** ~77%
-
-#### Files Modified by Claude
-- `src/components/Foo.tsx` — 89% AI (82 lines)
-- `src/hooks/useBar.ts` — 61% AI (44 lines)
+**Estimated cost:** unavailable — Copilot session data does not expose enough local billing data to estimate spend reliably.
 ```
 
 ### Running with a specific session ID
@@ -336,7 +332,35 @@ If you have multiple sessions and want metrics for a specific one:
 claude-attribution metrics <session-id>
 ```
 
-Session IDs are shown in `.claude/logs/tool-usage.jsonl`.
+Claude session IDs are shown in `.claude/logs/tool-usage.jsonl`. Copilot CLI session IDs are the directory names under `~/.copilot/session-state/`.
+
+### Copilot CLI support
+
+`claude-attribution` now supports **local GitHub Copilot CLI sessions** without adding a separate Copilot-specific install flow.
+
+How it works:
+
+1. The existing repo install still provides the post-commit hook and PR workflow.
+2. On commit or `/metrics`, the tool first tries the normal Claude-local data sources.
+3. If Claude session data is unavailable, it looks for a matching Copilot CLI session under `~/.copilot/session-state/<session-id>/events.jsonl`.
+4. It matches sessions by repo path, branch, and recency, then extracts:
+   - prompt count
+   - AI vs human active time
+   - tool usage
+   - skill usage
+   - agent usage
+   - dominant model / known token counts
+5. That normalized session data is attached to the git note so PR metrics can still be rebuilt later from durable note metadata.
+
+Optional prompt markers:
+
+- If your Copilot CLI workflow includes prompts beginning with `start work` and `create pr`, those are used as a tighter timing window.
+- If not, the tool falls back to the broader repo/branch session window automatically.
+
+Limitations:
+
+- Copilot CLI local session-state currently does **not** expose enough durable billing data to estimate cost reliably, so cost is rendered as **unavailable**.
+- Copilot CLI does not provide Claude-style file checkpoints, so attribution may fall back to commit/diff heuristics when no checkpoints exist.
 
 ### Checking raw attribution data
 
@@ -528,7 +552,7 @@ When no destination is configured, the workflow runs in **dry-run mode** — it
 
 Set secrets at the org level so they apply to all repos that use this tool. Multiple export destinations can be active simultaneously (e.g. both `OTEL_EXPORTER_OTLP_ENDPOINT` and `METRICS_WEBHOOK_URL`).
 
-**Model pricing (org variables — update when Anthropic changes pricing):**
+**Model pricing (Claude-only org variables — update when Anthropic changes pricing):**
 
 | Variable | Default | Description |
 |----------|---------|-------------|
@@ -541,7 +565,7 @@ Set secrets at the org level so they apply to all repos that use this tool. Mult
 | `CLAUDE_PRICE_CACHE_READ_MULT` | `0.1` | Fraction of input price for cache reads |
 | `CLAUDE_PRICE_CACHE_WRITE_MULT` | `1.25` | Fraction of input price for cache writes |
 
-Unrecognized model names (new Claude releases) fall back to Opus pricing. Set these as org-level **variables** (not secrets) — they're not sensitive.
+These pricing variables apply to **Claude token-based cost estimation only**. Copilot metrics currently report cost as **unavailable** unless a future durable billing/token source is added. Unrecognized Claude model names fall back to Opus pricing. Set these as org-level **variables** (not secrets) — they're not sensitive.
 
 
 ---
@@ -562,7 +586,13 @@ When generating PR metrics, branch commits that have no git note are checked for
 | `Co-authored-by:` trailer | `Co-authored-by: Claude <...>` |
 | `Co-authored-by:` trailer | `Co-authored-by: GitHub Copilot <...>` |
 
-If detected, all non-blank committed lines are counted as AI in the metrics output. No git note is written — this is a metrics-time synthesis only.
+If detected, all non-blank committed lines are counted as AI in the metrics output and the assistant runtime is labeled as Copilot or Claude when that can be inferred. No git note is written — this is a metrics-time synthesis only.
+
+This hosted/bot path is intentionally conservative:
+
+- attribution: **heuristic but durable enough for PR metrics**
+- assistant runtime: **best effort**
+- time/cost: **not available** from current hosted signals
 
 **Not detectable:** Copilot "Commit suggestion" (the button on PR review comments). Those commits are authored as the human who clicked the button — there is no metadata distinguishing them from a human edit. They will count as HUMAN.
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "claude-attribution",
-	"version": "1.8.0",
-	"description": "AI code attribution tracking for Claude Code sessions — checkpoint-based line diff approach",
+	"version": "1.9.0",
+	"description": "AI code attribution tracking for Claude Code and GitHub Copilot sessions",
 	"type": "module",
 	"bin": {
 		"claude-attribution": "bin/claude-attribution"

package/src/__tests__/claude-projects.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+import { mkdir } from "fs/promises";
+import { join } from "path";
+import { createTempContext } from "./integration-helpers.ts";
+import {
+	claudeProjectKey,
+	resolveClaudeProjectDir,
+} from "../metrics/claude-projects.ts";
+
+describe("claude project directory resolution", () => {
+	test("sanitizes dotted repo paths the same way Claude transcripts do", () => {
+		expect(claudeProjectKey("/Users/alice.smith/Code/my-repo")).toBe(
+			"-Users-alice-smith-Code-my-repo",
+		);
+	});
+
+	test("resolves sanitized transcript directories", async () => {
+		const ctx = await createTempContext("claude-projects");
+		try {
+			const repo = "/Users/alice.smith/Code/my-repo";
+			const projectsRoot = join(ctx.home, ".claude", "projects");
+			const dir = join(projectsRoot, "-Users-alice-smith-Code-my-repo");
+			await mkdir(dir, { recursive: true });
+			expect(await resolveClaudeProjectDir(repo, projectsRoot)).toBe(dir);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("falls back to legacy slash-only keys for backward compatibility", async () => {
+		const ctx = await createTempContext("claude-projects-legacy");
+		try {
+			const repo = "/Users/alice/Code/my-repo";
+			const projectsRoot = join(ctx.home, ".claude", "projects");
+			const dir = join(projectsRoot, "-Users-alice-Code-my-repo");
+			await mkdir(dir, { recursive: true });
+			expect(await resolveClaudeProjectDir(repo, projectsRoot)).toBe(dir);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+});

package/src/__tests__/copilot-session.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+import { parseCopilotSession, resolveCopilotSessionId } from "../metrics/copilot-session.ts";
+import { createTempContext, writeCopilotSession } from "./integration-helpers.ts";
+
+describe("copilot-session", () => {
+	test("parses local Copilot session metrics", async () => {
+		const ctx = await createTempContext("copilot-session");
+		const originalHome = process.env.HOME;
+		try {
+			process.env.HOME = ctx.home;
+			const sessionId = "copilot-session-1";
+			await writeCopilotSession(ctx.home, sessionId, [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: {
+						context: {
+							cwd: ctx.repo,
+							gitRoot: ctx.repo,
+							branch: "feature/copilot",
+						},
+					},
+				},
+				{
+					type: "user.message",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: { content: "Investigate parser" },
+				},
+				{
+					type: "tool.execution_start",
+					timestamp: "2026-04-01T10:00:05.000Z",
+					data: { toolName: "web_search" },
+				},
+				{
+					type: "tool.execution_start",
+					timestamp: "2026-04-01T10:00:06.000Z",
+					data: { toolName: "skill", arguments: { skill: "pr" } },
+				},
+				{
+					type: "tool.execution_complete",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { model: "gpt-5.4" },
+				},
+				{
+					type: "assistant.message",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { outputTokens: 320 },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T10:01:00.000Z",
+				},
+				{
+					type: "subagent.started",
+					timestamp: "2026-04-01T10:01:10.000Z",
+					data: { agentName: "ux-reviewer" },
+				},
+				{
+					type: "subagent.completed",
+					timestamp: "2026-04-01T10:01:30.000Z",
+					data: { model: "gpt-5-mini", totalTokens: 80 },
+				},
+				{
+					type: "user.message",
+					timestamp: "2026-04-01T10:02:00.000Z",
+					data: { content: "Create the PR" },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T10:03:00.000Z",
+				},
+			]);
+
+			const parsed = await parseCopilotSession(sessionId, ctx.repo);
+
+			expect(parsed).not.toBeNull();
+			expect(parsed?.provider).toBe("copilot");
+			expect(parsed?.humanPromptCount).toBe(2);
+			expect(parsed?.toolCounts).toEqual({ web_search: 1, skill: 1 });
+			expect(parsed?.skillNames).toEqual(["pr"]);
+			expect(parsed?.agentCounts).toEqual({ "ux-reviewer": 1 });
+			expect(parsed?.byModel).toEqual([
+				{
+					modelShort: "Unknown",
+					modelFull: "gpt-5-mini",
+					calls: 1,
+					inputTokens: 0,
+					outputTokens: 80,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+				},
+				{
+					modelShort: "Unknown",
+					modelFull: "gpt-5.4",
+					calls: 1,
+					inputTokens: 0,
+					outputTokens: 320,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+				},
+			]);
+			expect(parsed?.activeMinutes).toBe(3);
+			expect(parsed?.aiMinutes).toBe(2);
+			expect(parsed?.humanMinutes).toBe(1);
+			expect(parsed?.costMode).toBe("unavailable");
+		} finally {
+			process.env.HOME = originalHome;
+			await ctx.cleanup();
+		}
+	});
+
+	test("resolves the best matching session for a repo and branch", async () => {
+		const ctx = await createTempContext("copilot-session-resolve");
+		const originalHome = process.env.HOME;
+		try {
+			process.env.HOME = ctx.home;
+			await writeCopilotSession(ctx.home, "older-session", [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T09:00:00.000Z",
+					data: { context: { gitRoot: ctx.repo, branch: "main" } },
+				},
+			]);
+			await writeCopilotSession(ctx.home, "best-session", [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: {
+						context: { gitRoot: ctx.repo, cwd: ctx.repo, branch: "feature/copilot" },
+					},
+				},
+			]);
+
+			const resolved = await resolveCopilotSessionId(ctx.repo, "feature/copilot");
+			expect(resolved).toBe("best-session");
+		} finally {
+			process.env.HOME = originalHome;
+			await ctx.cleanup();
+		}
+	});
+});

package/src/__tests__/differ.test.ts

@@ -75,8 +75,8 @@ describe("attributeLines — basic classification", () => {
 	});
 
 	test("line not in after, committed file longer than after-snapshot → HUMAN", () => {
-		// When the committed file has more lines than the after-snapshot, the
-		// positional MIXED check doesn't fire for out-of-bounds positions.
+		// Insertions are treated as HUMAN unless we can anchor them as one-for-one
+		// replacements of Claude-authored lines.
 		const before: string[] = [];
 		const after = ["const x = 1;"]; // only 1 line
 		// Human committed 2 lines — position 1 is beyond after-snapshot length
@@ -86,6 +86,18 @@ describe("attributeLines — basic classification", () => {
 		expect(attribution[1]).toBe("HUMAN"); // position 1 is beyond after-snapshot — no MIXED
 	});
 
+	test("human insertion above AI lines does not create false MIXED classifications", () => {
+		const before: string[] = [];
+		const after = ["const a = 1;", "const b = 2;"];
+		const committed = ["// intro", "const a = 1;", "const b = 2;"];
+		const { attribution, stats } = attributeLines(before, after, committed);
+		expect(attribution).toEqual(["HUMAN", "AI", "AI"]);
+		expect(stats.ai).toBe(2);
+		expect(stats.human).toBe(1);
+		expect(stats.mixed).toBe(0);
+		expect(stats.pctAi).toBe(67);
+	});
+
 	test("empty lines always → HUMAN regardless of snapshot", () => {
 		const before: string[] = [];
 		const after = ["", "const x = 1;", ""];

package/src/__tests__/git-notes.test.ts

@@ -137,4 +137,32 @@ timestamp: new Date().toISOString(),
 }),
 ).toBe(false);
 });
+
+test("buildAllAiResult tags hosted Copilot commits with assistant runtime", async () => {
+const ctx = await createTempContext("claude-attribution-copilot-bot");
+try {
+await initGitRepo(ctx.repo);
+await runCommand("git", ["config", "user.name", "copilot[bot]"], { cwd: ctx.repo });
+await runCommand(
+"git",
+["config", "user.email", "000000+copilot[bot]@users.noreply.github.com"],
+{ cwd: ctx.repo },
+);
+await writeFile(join(ctx.repo, "agent.ts"), "export const generated = true;\n");
+await commitAll(
+ctx.repo,
+"feat: add hosted change\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>",
+);
+const sha = await currentSha(ctx.repo);
+
+const result = await buildAllAiResult(ctx.repo, sha);
+
+expect(result.assistantRuntime).toEqual({
+vendor: "copilot",
+client: "GitHub Copilot",
+});
+} finally {
+await ctx.cleanup();
+}
+});
 });

package/src/__tests__/installed-repos.test.ts

@@ -34,8 +34,9 @@ describe("installed repo registry", () => {
 				"1.7.0",
 			);
 
-			await unregisterInstalledRepo(repo2, ctx.home);
+			expect(await unregisterInstalledRepo(repo2, ctx.home)).toBe(true);
 			expect(await readInstalledRepoRegistry(ctx.home)).toHaveLength(1);
+			expect(await unregisterInstalledRepo(repo2, ctx.home)).toBe(false);
 
 			await writeInstalledRepoRegistry(
 				[

package/src/__tests__/integration-helpers.ts

@@ -10,6 +10,7 @@ import {
 import { tmpdir } from "os";
 import { dirname, join, resolve } from "path";
 import { promisify } from "util";
+import { claudeProjectKey } from "../metrics/claude-projects.ts";
 
 const execFileAsync = promisify(execFile);
 
@@ -113,7 +114,7 @@ export async function writeJsonl(
 }
 
 export function transcriptDirFor(home: string, repo: string): string {
-	return join(home, ".claude", "projects", repo.replace(/\//g, "-"));
+	return join(home, ".claude", "projects", claudeProjectKey(repo));
 }
 
 export async function writeTranscript(
@@ -127,6 +128,16 @@ export async function writeTranscript(
 	await writeJsonl(join(dir, `${sessionId}.jsonl`), entries);
 }
 
+export async function writeCopilotSession(
+	home: string,
+	sessionId: string,
+	entries: unknown[],
+): Promise<void> {
+	const dir = join(home, ".copilot", "session-state", sessionId);
+	await mkdir(dir, { recursive: true });
+	await writeJsonl(join(dir, "events.jsonl"), entries);
+}
+
 export async function readJson(path: string): Promise<unknown> {
 	return JSON.parse(await readFile(path, "utf8"));
 }

package/src/__tests__/integration.test.ts

@@ -17,6 +17,7 @@ import {
 	initGitRepo,
 	readJson,
 	runCommand,
+	writeCopilotSession,
 	writeJsonl,
 	writeTranscript,
 } from "./integration-helpers.ts";
@@ -207,7 +208,145 @@ describe("integration", () => {
 			expect(metrics.stdout).toContain("**Skills:** /pr");
 			expect(metrics.stdout).toContain("**Agents:** code-review");
 			expect(metrics.stdout).toContain("**External tools:** WebSearch ×2");
-			expect(metrics.stdout).toContain("**Estimated cost:**");
+			expect(metrics.stdout).toContain("**Estimated cost:** unavailable");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("post-commit falls back to Copilot session-state metadata", async () => {
+		const ctx = await createTempContext("copilot-attribution-commit");
+		try {
+			await initGitRepo(ctx.repo);
+			const filePath = join(ctx.repo, "src.ts");
+			await writeFile(filePath, "const value = 1;\n");
+			await commitAll(ctx.repo, "initial");
+
+			await writeFile(filePath, "const value = 1;\nconst nextValue = 2;\n");
+			await commitAll(ctx.repo, "feature work");
+
+			const branch = (
+				await runCommand("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+					cwd: ctx.repo,
+				})
+			).stdout.trim();
+			const sessionId = "copilot-session-commit-1";
+			await writeCopilotSession(ctx.home, sessionId, [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: {
+						context: {
+							cwd: ctx.repo,
+							gitRoot: ctx.repo,
+							branch,
+						},
+					},
+				},
+				{
+					type: "user.message",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: { content: "start work" },
+				},
+				{
+					type: "tool.execution_start",
+					timestamp: "2026-04-01T10:00:05.000Z",
+					data: { toolName: "web_search" },
+				},
+				{
+					type: "tool.execution_complete",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { model: "gpt-5.4" },
+				},
+				{
+					type: "assistant.message",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { outputTokens: 240 },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T10:01:00.000Z",
+				},
+			]);
+
+			await runCommand(CLI_BIN, ["hook", "post-commit"], {
+				cwd: ctx.repo,
+				env: {
+					HOME: ctx.home,
+					COPILOT_CLI: "1",
+					COPILOT_CLI_BINARY_VERSION: "1.0.15",
+				},
+			});
+
+			const note = JSON.parse(
+				(
+					await runCommand(
+						"git",
+						["notes", "--ref", "claude-attribution", "show", "HEAD"],
+						{ cwd: ctx.repo },
+					)
+				).stdout,
+			) as AttributionResult;
+
+			expect(note.session).toBe(sessionId);
+			expect(note.totals.ai).toBeGreaterThan(0);
+			expect(note.modelUsage).toEqual([
+				{
+					modelFull: "gpt-5.4",
+					modelShort: "Unknown",
+					calls: 1,
+					inputTokens: 0,
+					outputTokens: 240,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+				},
+			]);
+			expect(note.sessionMetrics?.toolCounts).toEqual({ web_search: 1 });
+			expect(note.sessionMetrics?.humanPromptCount).toBe(1);
+			expect(note.assistantRuntime).toEqual({
+				vendor: "copilot",
+				client: "GitHub Copilot CLI",
+				clientVersion: "1.0.15",
+				modelFamily: "gpt-5.4",
+			});
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("metrics synthesizes hosted Copilot bot commits without local notes", async () => {
+		const ctx = await createTempContext("copilot-hosted-metrics");
+		try {
+			await initGitRepo(ctx.repo);
+			await writeFile(join(ctx.repo, "baseline.ts"), "export const baseline = true;\n");
+			await commitAll(ctx.repo, "initial");
+			await runCommand("git", ["config", "user.name", "copilot[bot]"], {
+				cwd: ctx.repo,
+			});
+			await runCommand(
+				"git",
+				["config", "user.email", "000000+copilot[bot]@users.noreply.github.com"],
+				{ cwd: ctx.repo },
+			);
+			await writeFile(
+				join(ctx.repo, "agent.ts"),
+				"export const generated = true;\n",
+			);
+			await commitAll(
+				ctx.repo,
+				"feat: hosted change\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>",
+			);
+
+			const metrics = await runCommand(CLI_BIN, ["metrics"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			expect(metrics.stdout).toContain("## AI Coding Metrics");
+			expect(metrics.stdout).toContain("**AI contribution: ~50%**");
+			expect(metrics.stdout).toContain("**Assistant runtime:** GitHub Copilot");
+			expect(metrics.stdout).toContain("`agent.ts` — 50% AI (1 lines)");
+			expect(metrics.stdout).not.toContain("**Estimated cost:**");
 		} finally {
 			await ctx.cleanup();
 		}