claude-attribution 1.9.0 → 1.9.4

package/README.md

@@ -68,6 +68,51 @@ Up to three workflows are installed into repos that use this tool — one always
 
 ---
 
+## Publishing this package to npm
+
+This repo is set up to publish to npm from GitHub Actions on the **self-hosted runner** using an npm publish token. That avoids local OTP prompts while still fitting the repo's network restrictions.
+
+### One-time npm + GitHub setup
+
+This part must be done by a package owner:
+
+1. In npm, open the `claude-attribution` package and set **Publishing access** to **Require two-factor authentication or a granular access token with bypass 2fa enabled**.
+2. Create a **granular npm access token** that can publish `claude-attribution` and has **bypass 2FA** enabled.
+3. In GitHub, save that token as the `NPM_TOKEN` Actions secret for this repository (or an org secret exposed to this repo).
+4. Optional: you can leave the npm trusted publisher entry in place, but this self-hosted workflow authenticates with `NPM_TOKEN`.
+5. Plan to rotate the npm token periodically. npm currently caps granular token lifetime at 90 days.
+
+After that, the workflow in `.github/workflows/publish-npm.yml` can publish on the self-hosted runner without an interactive OTP prompt.
+
+### Release process
+
+This repo uses a **bump → merge → tag** publish flow:
+
+1. Bump `package.json` to the release version and update `CHANGELOG.md` in the PR.
+2. Merge that PR to `main`.
+3. Tag the merged commit from `main`:
+
+```bash
+git checkout main
+git pull --ff-only
+git tag v1.9.1
+git push origin v1.9.1
+```
+
+4. GitHub Actions runs `publish-npm.yml` and publishes that exact version to npm.
+
+### Important rules
+
+- The git tag must exactly match `package.json` without the `v` prefix.
+  - Example: tag `v1.9.1` requires `"version": "1.9.1"` in `package.json`
+- The workflow fails if the tag and package version do not match.
+- The workflow also fails if that package version is already published.
+- `NPM_TOKEN` must exist in GitHub Actions before the tag is pushed.
+- The npm token must be a granular publish token with bypass-2FA enabled for this package.
+- The self-hosted workflow publishes **without** `--provenance` because npm only accepts provenance from GitHub-hosted runners.
+
+---
+
 ## For Repo Maintainers: Installing Into a Repo
 
 ### Prerequisites
@@ -164,7 +209,7 @@ git push origin refs/notes/claude-attribution-map
 Marks every currently tracked file as AI-written at HEAD. After this, PR metrics will show:
 ```
 Codebase: ~100% AI (4150 / 4150 lines)
-This PR: 184 lines changed (4% of codebase) · 77% Claude edits · 142 AI lines
+This PR: 184 lines changed (4% of codebase) · 77% AI edits · 142 AI-attributed changed lines
 ```
 
 **Option 2 — Repo is human-written, or a mix (`--human` / no flag):**
@@ -251,7 +296,7 @@ The metrics block injected into the PR body looks like (when the cumulative mini
 > ## AI Coding Metrics
 >
 > **Codebase: ~77% AI** (3200 / 4150 lines)
-> **This PR:** 184 lines changed (4% of codebase) · 77% AI edits · 142 AI lines
+> **This PR:** 184 lines changed (4% of codebase) · 77% AI edits · 142 AI-attributed changed lines
 > **Session:** 12 prompts · 24m total (18m AI · 6m human)
 > **Assistant runtime:** Claude Code (claude-sonnet-4-6)
 >
@@ -278,6 +323,8 @@ For **Copilot CLI** sessions, the same block is rendered with provider-aware dif
 - 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 `This PR` line is based on the branch diff against the base branch, not the full final size of every touched file.
+
 The block is wrapped in HTML comments for idempotent updates — re-running replaces the existing block rather than appending:
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claude-attribution",
-	"version": "1.9.0",
+	"version": "1.9.4",
 	"description": "AI code attribution tracking for Claude Code and GitHub Copilot sessions",
 	"type": "module",
 	"bin": {

package/src/__tests__/integration.test.ts

@@ -2,10 +2,14 @@ import { describe, expect, test } from "bun:test";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { saveCheckpoint } from "../attribution/checkpoint.ts";
-import type { AttributionResult } from "../attribution/differ.ts";
+import { hashLine, type AttributionResult } from "../attribution/differ.ts";
 import { NOTES_REF, writeNote } from "../attribution/git-notes.ts";
 import { pushNotesRef } from "../attribution/notes-sync.ts";
-import { writeMinimap, type MinimapResult } from "../attribution/minimap.ts";
+import {
+	hashSetToString,
+	writeMinimap,
+	type MinimapResult,
+} from "../attribution/minimap.ts";
 import { readInstalledRepoRegistry } from "../setup/installed-repos.ts";
 import {
 	CLI_BIN,
@@ -94,8 +98,9 @@ describe("integration", () => {
 				cwd: ctx.repo,
 				env: {
 					HOME: ctx.home,
-					COPILOT_CLI: "1",
-					COPILOT_CLI_BINARY_VERSION: "1.0.14",
+					COPILOT_CLI: "",
+					COPILOT_CLI_BINARY_VERSION: "",
+					ANTHROPIC_MODEL: "claude-sonnet-4-6",
 				},
 			});
 
@@ -117,9 +122,9 @@ describe("integration", () => {
 			expect(note.sessionMetrics?.humanPromptCount).toBe(1);
 			expect(note.sessionMetrics?.activeMinutes).toBe(2);
 			expect(note.assistantRuntime).toEqual({
-				vendor: "copilot",
-				client: "GitHub Copilot CLI",
-				clientVersion: "1.0.14",
+				vendor: "claude",
+				client: "Claude Code",
+				modelFamily: "claude-sonnet-4-6",
 			});
 		} finally {
 			await ctx.cleanup();
@@ -214,6 +219,105 @@ describe("integration", () => {
 		}
 	});
 
+	test("metrics headline uses diff-scoped PR stats instead of full touched file totals", async () => {
+		const ctx = await createTempContext("claude-attribution-pr-diff");
+		try {
+			await initGitRepo(ctx.repo);
+			await runCommand("git", ["branch", "-M", "main"], { cwd: ctx.repo });
+
+			const remote = join(ctx.root, "origin.git");
+			await runCommand("git", ["init", "--bare", remote], { cwd: ctx.root });
+			await runCommand("git", ["remote", "add", "origin", remote], {
+				cwd: ctx.repo,
+			});
+
+			const baseContent =
+				Array.from({ length: 100 }, (_, i) => `line ${i + 1}`).join("\n") + "\n";
+			await writeFile(join(ctx.repo, "README.md"), baseContent);
+			await commitAll(ctx.repo, "initial");
+			const baseSha = await currentSha(ctx.repo);
+			await runCommand("git", ["push", "-u", "origin", "main"], { cwd: ctx.repo });
+
+			const baseMinimap: MinimapResult = {
+				commit: baseSha,
+				timestamp: "2026-03-01T10:00:00.000Z",
+				files: [
+					{
+						path: "README.md",
+						ai_hashes: "",
+						ai: 0,
+						human: 100,
+						total: 100,
+						pctAi: 0,
+					},
+				],
+				totals: { ai: 0, human: 100, total: 100, pctAi: 0 },
+			};
+			await writeMinimap(baseMinimap, ctx.repo, baseSha);
+
+			await runCommand("git", ["checkout", "-b", "feature/diff-metrics"], {
+				cwd: ctx.repo,
+			});
+			await writeFile(
+				join(ctx.repo, "README.md"),
+				`${baseContent}AI-added line 1\nAI-added line 2\n`,
+			);
+			await commitAll(ctx.repo, "feature work");
+			const headSha = await currentSha(ctx.repo);
+
+			const note: AttributionResult = {
+				commit: headSha,
+				session: "session-pr-diff-1",
+				branch: "feature/diff-metrics",
+				timestamp: "2026-03-01T10:05:00.000Z",
+				files: [
+					{
+						path: "README.md",
+						ai: 2,
+						human: 100,
+						mixed: 0,
+						total: 102,
+						pctAi: 2,
+					},
+				],
+				totals: { ai: 2, human: 100, mixed: 0, total: 102, pctAi: 2 },
+			};
+			await writeNote(note, ctx.repo, headSha);
+
+			const aiHashes = hashSetToString(
+				new Set([hashLine("AI-added line 1"), hashLine("AI-added line 2")]),
+			);
+			const headMinimap: MinimapResult = {
+				commit: headSha,
+				timestamp: "2026-03-01T10:05:00.000Z",
+				files: [
+					{
+						path: "README.md",
+						ai_hashes: aiHashes,
+						ai: 2,
+						human: 100,
+						total: 102,
+						pctAi: 2,
+					},
+				],
+				totals: { ai: 2, human: 100, total: 102, pctAi: 2 },
+			};
+			await writeMinimap(headMinimap, ctx.repo, headSha);
+
+			const metrics = await runCommand(CLI_BIN, ["metrics"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			expect(metrics.stdout).toContain(
+				"**This PR:** 2 lines changed (2% of codebase) · 100% AI edits · 2 AI-attributed changed lines",
+			);
+			expect(metrics.stdout).not.toContain("**This PR:** 102 lines changed");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
 	test("post-commit falls back to Copilot session-state metadata", async () => {
 		const ctx = await createTempContext("copilot-attribution-commit");
 		try {
@@ -314,6 +418,151 @@ describe("integration", () => {
 		}
 	});
 
+	test("Copilot sessions win over stale Claude session markers and transcripts", async () => {
+		const ctx = await createTempContext("copilot-session-precedence");
+		try {
+			await initGitRepo(ctx.repo);
+			const filePath = join(ctx.repo, "src.ts");
+			await writeFile(filePath, "const value = 1;\n");
+			await commitAll(ctx.repo, "initial");
+
+			const staleClaudeSession = "claude-session-stale-1";
+			await mkdir(join(ctx.repo, ".claude", "attribution-state"), {
+				recursive: true,
+			});
+			await writeFile(
+				join(ctx.repo, ".claude", "attribution-state", "current-session"),
+				staleClaudeSession,
+			);
+			await writeJsonl(join(ctx.repo, ".claude", "logs", "tool-usage.jsonl"), [
+				{
+					timestamp: "2026-03-30T01:09:44.678Z",
+					session: staleClaudeSession,
+					tool: "Bash",
+				},
+			]);
+			await writeTranscript(ctx.home, ctx.repo, staleClaudeSession, [
+				{
+					type: "user",
+					timestamp: "2026-03-30T01:00:00.000Z",
+				},
+				{
+					type: "assistant",
+					timestamp: "2026-03-30T01:01:00.000Z",
+					message: {
+						model: "claude-sonnet-4-6",
+						usage: {
+							input_tokens: 2000,
+							output_tokens: 500,
+							cache_creation_input_tokens: 100,
+							cache_read_input_tokens: 800,
+						},
+					},
+				},
+			]);
+
+			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 copilotSession = "copilot-session-precedence-1";
+			await writeCopilotSession(ctx.home, copilotSession, [
+				{
+					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_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(copilotSession);
+			expect(note.assistantRuntime).toEqual({
+				vendor: "copilot",
+				client: "GitHub Copilot CLI",
+				clientVersion: "1.0.15",
+				modelFamily: "gpt-5.4",
+			});
+			expect(note.modelUsage).toEqual([
+				{
+					modelFull: "gpt-5.4",
+					modelShort: "Unknown",
+					calls: 1,
+					inputTokens: 0,
+					outputTokens: 240,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+				},
+			]);
+
+			const metrics = await runCommand(CLI_BIN, ["metrics"], {
+				cwd: ctx.repo,
+				env: {
+					HOME: ctx.home,
+					COPILOT_CLI: "1",
+					COPILOT_CLI_BINARY_VERSION: "1.0.15",
+				},
+			});
+
+			expect(metrics.stdout).toContain(
+				"**Assistant runtime:** GitHub Copilot CLI (v1.0.15 · gpt-5.4)",
+			);
+			expect(metrics.stdout).toContain("| Model | Calls | Known Tokens |");
+			expect(metrics.stdout).toContain("| gpt-5.4 | 1 | 240 |");
+			expect(metrics.stdout).toContain("**Estimated cost:** unavailable");
+			expect(metrics.stdout).not.toContain("claude-sonnet-4-6");
+			expect(metrics.stdout).not.toContain("**Estimated cost:** ~$");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
 	test("metrics synthesizes hosted Copilot bot commits without local notes", async () => {
 		const ctx = await createTempContext("copilot-hosted-metrics");
 		try {

package/src/__tests__/minimap-bulk.test.ts

@@ -47,6 +47,23 @@ await ctx.cleanup();
 }
 });
 
+test("all-AI baseline records blank lines as AI-preserving hashes", async () => {
+const ctx = await createTempContext("claude-attribution-minimap-blank-carry");
+try {
+await initGitRepo(ctx.repo);
+await writeFile(join(ctx.repo, "doc.md"), "alpha\n\nbeta\n");
+await runCommand("git", ["add", "."], { cwd: ctx.repo });
+await runCommand("git", ["commit", "-m", "baseline"], { cwd: ctx.repo });
+
+const baseline = await buildAllAiMinimap(ctx.repo);
+const prevEntry = baseline.files.find((file) => file.path === "doc.md");
+expect(prevEntry).toMatchObject({ ai: 3, human: 0, total: 3, pctAi: 100 });
+expect(prevEntry?.ai_hashes.length).toBeGreaterThanOrEqual(16);
+} finally {
+await ctx.cleanup();
+}
+});
+
 test("marks only recently changed files as AI in ai-since minimaps", async () => {
 const ctx = await createTempContext("claude-attribution-minimap-ai-since");
 try {

package/src/__tests__/minimap.test.ts

@@ -99,7 +99,7 @@ describe("computeMinimapFile", () => {
 		expect(hashSetFromString(result.ai_hashes).has(hash)).toBe(false);
 	});
 
-	test("blank line always human (never in ai_hashes)", () => {
+	test("blank line stays AI when the blank-line marker is present", () => {
 		const aiHash = hashLine("");
 		const result = computeMinimapFile(
 			"foo.ts",
@@ -107,12 +107,12 @@ describe("computeMinimapFile", () => {
 			new Set([aiHash]),
 			new Set([aiHash]),
 		);
-		expect(result.ai).toBe(0);
-		expect(result.human).toBe(1);
-		expect(result.ai_hashes).toBe("");
+		expect(result.ai).toBe(1);
+		expect(result.human).toBe(0);
+		expect(result.ai_hashes).toBe(aiHash);
 	});
 
-	test("whitespace-only line treated as blank (always human)", () => {
+	test("whitespace-only line treated as blank and can carry AI attribution", () => {
 		const line = "   ";
 		const aiHash = hashLine(line);
 		const result = computeMinimapFile(
@@ -121,8 +121,8 @@ describe("computeMinimapFile", () => {
 			new Set([aiHash]),
 			new Set([aiHash]),
 		);
-		expect(result.ai).toBe(0);
-		expect(result.human).toBe(1);
+		expect(result.ai).toBe(1);
+		expect(result.human).toBe(0);
 	});
 
 	test("MIXED line — not in currentAiHashes → human even if in prevAiHashSet", () => {

package/src/attribution/commit.ts

@@ -91,7 +91,12 @@ async function resolveSessionForCommit(
 	repoRoot: string,
 	changedFiles: string[],
 	branch: string | null,
+	runtime: AssistantRuntimeInfo | null,
 ): Promise<string | null> {
+	if (runtime?.vendor === "copilot") {
+		return await resolveCopilotSessionId(repoRoot, branch).catch(() => null);
+	}
+
 	const fromCurrentSession = await readCurrentSession(repoRoot);
 	if (fromCurrentSession) return fromCurrentSession;
 
@@ -164,7 +169,13 @@ async function main() {
 			.catch(() => null as string | null),
 		renamedFilesInCommit(repoRoot),
 	]);
-	const sessionId = await resolveSessionForCommit(repoRoot, changedFiles, branch);
+	const detectedRuntime = detectAssistantRuntime();
+	const sessionId = await resolveSessionForCommit(
+		repoRoot,
+		changedFiles,
+		branch,
+		detectedRuntime,
+	);
 
 	// Process files in parallel — each file attribution is independent.
 	// Return type includes attribution[] so the minimap block can build currentAiHashes.
@@ -250,8 +261,6 @@ async function main() {
 	};
 	const notesRefsToSync = [NOTES_REF];
 
-	const detectedRuntime = detectAssistantRuntime();
-
 	// Attach session usage metadata (non-fatal if unavailable)
 	if (sessionId) {
 		const [tx, toolEntries, agentEntries] = await Promise.all([

package/src/attribution/git-notes.ts

@@ -185,17 +185,21 @@ export async function renamedFilesInCommit(
  * Falls back to all commits reachable from HEAD if no remote ref is found.
  */
 export async function getBranchCommitShas(repoRoot: string): Promise<string[]> {
-	const base = await run("git", ["merge-base", "HEAD", "origin/HEAD"], repoRoot)
-		.catch(() => run("git", ["merge-base", "HEAD", "origin/main"], repoRoot))
-		.catch(() => run("git", ["merge-base", "HEAD", "origin/master"], repoRoot))
-		.catch(() => null);
-	const range = base ? `${(base as string).trim()}..HEAD` : "HEAD";
+	const base = await getBranchBaseSha(repoRoot);
+	const range = base ? `${base}..HEAD` : "HEAD";
 	const out = await run("git", ["log", "--format=%H", range], repoRoot).catch(
 		() => "",
 	);
 	return out ? out.split("\n").filter(Boolean) : [];
 }
 
+export async function getBranchBaseSha(repoRoot: string): Promise<string | null> {
+	return await run("git", ["merge-base", "HEAD", "origin/HEAD"], repoRoot)
+		.catch(() => run("git", ["merge-base", "HEAD", "origin/main"], repoRoot))
+		.catch(() => run("git", ["merge-base", "HEAD", "origin/master"], repoRoot))
+		.catch(() => null);
+}
+
 /**
  * Read the committed content of a file at HEAD as a raw string.
  *

package/src/attribution/minimap.ts

@@ -8,7 +8,8 @@
  * Design:
  *   - Only `ai_hashes` is stored; Human = any committed line NOT in ai_hashes.
  *   - ai_hashes is a concatenated string of 16-char hex hashes (no separator).
- *   - Blank lines are always Human and never appear in ai_hashes.
+ *   - Blank lines use the hash of the empty string so `init --ai` style baselines
+ *     can preserve all-AI files across later commits.
  *   - Full state (all tracked files) is stored on every commit for simple reads.
  *
  * Carry-forward algorithm (per committed line hash):
@@ -24,6 +25,7 @@ import { join } from "path";
 import { hashLine } from "./differ.ts";
 
 const execFileAsync = promisify(execFile);
+const BLANK_LINE_HASH = hashLine("");
 
 export const MINIMAP_NOTES_REF = "refs/notes/claude-attribution-map";
 
@@ -81,8 +83,15 @@ export function computeMinimapFile(
 
 	for (const line of committedLines) {
 		if (line.trim() === "") {
-			// Blank lines carry no attribution signal — always Human
-			human++;
+			if (
+				currentAiHashes.has(BLANK_LINE_HASH) ||
+				prevAiHashSet.has(BLANK_LINE_HASH)
+			) {
+				newAiHashes.add(BLANK_LINE_HASH);
+				ai++;
+			} else {
+				human++;
+			}
 			continue;
 		}
 		const hash = hashLine(line);
@@ -232,7 +241,9 @@ export async function buildAllAiMinimap(
 					const total = lines.length;
 					const aiHashes = new Set<string>();
 					for (const line of lines) {
-						if (line.trim() !== "") aiHashes.add(hashLine(line));
+						aiHashes.add(
+							line.trim() === "" ? BLANK_LINE_HASH : hashLine(line),
+						);
 					}
 					return {
 						path: relPath,
@@ -315,7 +326,9 @@ export async function buildAiSinceMinimap(
 					}
 					const aiHashes = new Set<string>();
 					for (const line of lines) {
-						if (line.trim() !== "") aiHashes.add(hashLine(line));
+						aiHashes.add(
+							line.trim() === "" ? BLANK_LINE_HASH : hashLine(line),
+						);
 					}
 					return {
 						path: relPath,

package/src/metrics/collect.ts

@@ -18,18 +18,28 @@ import { type TranscriptResult } from "./transcript.ts";
 import {
 	listNotes,
 	readNote,
+	getBranchBaseSha,
 	getBranchCommitShas,
 	getCommitMeta,
 	isKnownAiActorCommit,
 	buildAllAiResult,
+	committedContent,
+	committedContentAt,
+	currentBranch,
 } from "../attribution/git-notes.ts";
 import {
 	aggregateTotals,
 	type AttributionResult,
 	type FileAttribution,
+	hashLine,
 } from "../attribution/differ.ts";
 import { SESSION_ID_RE } from "../attribution/checkpoint.ts";
-import { readMinimap, listMinimapNotes } from "../attribution/minimap.ts";
+import {
+	hashSetFromString,
+	readMinimap,
+	listMinimapNotes,
+} from "../attribution/minimap.ts";
+import { detectAssistantRuntime } from "../attribution/runtime.ts";
 import {
 	buildSessionMetrics,
 	mergeCountRecords,
@@ -58,6 +68,11 @@ export interface MetricsData {
 		total: number;
 		pctAi: number;
 	} | null;
+	prDiffStats: {
+		ai: number;
+		total: number;
+		pctAi: number;
+	} | null;
 }
 
 async function readSessionStart(repoRoot: string): Promise<Date | null> {
@@ -78,15 +93,9 @@ async function readSessionStart(repoRoot: string): Promise<Date | null> {
 }
 
 async function getBranchStartTime(repoRoot: string): Promise<Date | null> {
-	for (const ref of ["origin/HEAD", "origin/main", "origin/master"]) {
+	const forkPoint = await getBranchBaseSha(repoRoot);
+	if (forkPoint) {
 		try {
-			const { stdout: base } = await execFileAsync(
-				"git",
-				["merge-base", "HEAD", ref],
-				{ cwd: repoRoot },
-			);
-			const forkPoint = base.trim();
-			if (!forkPoint) continue;
 			const { stdout: log } = await execFileAsync(
 				"git",
 				["log", "--reverse", "--format=%ct", `${forkPoint}..HEAD`],
@@ -95,12 +104,191 @@ async function getBranchStartTime(repoRoot: string): Promise<Date | null> {
 			const firstTs = log.trim().split("\n").filter(Boolean)[0];
 			if (firstTs) return new Date(parseInt(firstTs, 10) * 1000);
 		} catch {
-			continue;
+			// Fall through.
 		}
 	}
 	return null;
 }
 
+function parseChangedLineNumbers(diff: string): {
+	added: number[];
+	removed: number[];
+} {
+	const added: number[] = [];
+	const removed: number[] = [];
+	let nextNewLine = 0;
+	let nextOldLine = 0;
+
+	for (const line of diff.split("\n")) {
+		const hunk = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+		if (hunk) {
+			nextOldLine = parseInt(hunk[1] ?? "0", 10);
+			nextNewLine = parseInt(hunk[2] ?? "0", 10);
+			continue;
+		}
+
+		if (line.startsWith("+++") || line.startsWith("---") || line === "") {
+			continue;
+		}
+
+		if (line.startsWith("+")) {
+			added.push(nextNewLine);
+			nextNewLine++;
+			continue;
+		}
+
+		if (line.startsWith("-")) {
+			removed.push(nextOldLine);
+			nextOldLine++;
+			continue;
+		}
+
+		if (line.startsWith("\\")) continue;
+
+		nextOldLine++;
+		nextNewLine++;
+	}
+
+	return { added, removed };
+}
+
+async function getBranchDiffStats(
+	repoRoot: string,
+): Promise<{ ai: number; total: number; pctAi: number } | null> {
+	const baseSha = await getBranchBaseSha(repoRoot);
+	if (!baseSha) return null;
+
+	const [headMinimap, baseMinimap, changedFilesOutput, renameStatusOutput] =
+		await Promise.all([
+			readMinimap(repoRoot, "HEAD"),
+			readMinimap(repoRoot, baseSha).catch(() => null),
+			execFileAsync(
+				"git",
+				["diff", "--name-only", "--find-renames", `${baseSha}..HEAD`],
+				{ cwd: repoRoot },
+			)
+				.then(({ stdout }) => stdout)
+				.catch(() => ""),
+			execFileAsync(
+				"git",
+				["diff", "--name-status", "--find-renames", `${baseSha}..HEAD`],
+				{ cwd: repoRoot },
+			)
+				.then(({ stdout }) => stdout)
+				.catch(() => ""),
+		]);
+	if (!headMinimap) return null;
+
+	const headAiByPath = new Map(
+		headMinimap.files.map((file) => [file.path, hashSetFromString(file.ai_hashes)]),
+	);
+	const baseAiByPath = new Map(
+		(baseMinimap?.files ?? []).map((file) => [
+			file.path,
+			hashSetFromString(file.ai_hashes),
+		]),
+	);
+	const renamedBasePathByCurrentPath = new Map<string, string>();
+	for (const line of renameStatusOutput.split("\n").filter(Boolean)) {
+		const [status, oldPath, newPath] = line.split("\t");
+		if (!status?.startsWith("R") || !oldPath || !newPath) continue;
+		renamedBasePathByCurrentPath.set(newPath, oldPath);
+	}
+
+	const changedFiles = changedFilesOutput.split("\n").filter(Boolean);
+	if (changedFiles.length === 0) {
+		return { ai: 0, total: 0, pctAi: 0 };
+	}
+
+	const fileStats = await Promise.all(
+		changedFiles.map(async (path) => {
+			const basePath = renamedBasePathByCurrentPath.get(path) ?? path;
+			const [numstatResult, diffResult, headContent, baseContent] = await Promise.all([
+				execFileAsync(
+					"git",
+					[
+						"diff",
+						"--numstat",
+						"--find-renames",
+						`${baseSha}..HEAD`,
+						"--",
+						path,
+					],
+					{ cwd: repoRoot },
+				)
+					.then(({ stdout }) => stdout.trim())
+					.catch(() => ""),
+				execFileAsync(
+					"git",
+					[
+						"diff",
+						"--unified=0",
+						"--no-color",
+						"--find-renames",
+						`${baseSha}..HEAD`,
+						"--",
+						path,
+					],
+					{ cwd: repoRoot },
+				)
+					.then(({ stdout }) => stdout)
+					.catch(() => ""),
+				committedContent(repoRoot, path),
+				committedContentAt(repoRoot, baseSha, basePath),
+			]);
+
+			const numstatLine = numstatResult.split("\n").find(Boolean);
+			if (!numstatLine) return { ai: 0, total: 0 };
+
+			const [additionsRaw, deletionsRaw] = numstatLine.split("\t");
+			if (!additionsRaw || !deletionsRaw) return { ai: 0, total: 0 };
+			if (additionsRaw === "-" || deletionsRaw === "-") {
+				return { ai: 0, total: 0 };
+			}
+
+			const additions = parseInt(additionsRaw, 10);
+			const deletions = parseInt(deletionsRaw, 10);
+			const total = additions + deletions;
+			if (total === 0) return { ai: 0, total: 0 };
+
+			const { added, removed } = parseChangedLineNumbers(diffResult);
+			const headLines = headContent?.split("\n") ?? [];
+			const baseLines = baseContent?.split("\n") ?? [];
+			const headAiHashes = headAiByPath.get(path) ?? new Set<string>();
+			const baseAiHashes = baseAiByPath.get(basePath) ?? new Set<string>();
+
+			let ai = 0;
+			for (const lineNumber of added) {
+				const line = headLines[lineNumber - 1];
+				if (line !== undefined && headAiHashes.has(hashLine(line))) {
+					ai++;
+				}
+			}
+			for (const lineNumber of removed) {
+				const line = baseLines[lineNumber - 1];
+				if (line !== undefined && baseAiHashes.has(hashLine(line))) {
+					ai++;
+				}
+			}
+
+			return { ai, total };
+		}),
+	);
+
+	const totals = fileStats.reduce(
+		(acc, file) => ({
+			ai: acc.ai + file.ai,
+			total: acc.total + file.total,
+		}),
+		{ ai: 0, total: 0 },
+	);
+	return {
+		ai: totals.ai,
+		total: totals.total,
+		pctAi: totals.total > 0 ? Math.round((totals.ai / totals.total) * 100) : 0,
+	};
+}
+
 /**
  * Resolve the most recent Claude session ID for this repo.
  *
@@ -113,6 +301,18 @@ async function getBranchStartTime(repoRoot: string): Promise<Date | null> {
  * table, tool counts) even when attribution was installed after the editing session.
  */
 async function resolveSessionId(repoRoot: string): Promise<string | null> {
+	const runtime = detectAssistantRuntime();
+	if (runtime?.vendor === "copilot") {
+		const branch = await currentBranch(repoRoot).catch(() => null);
+		const copilotSessionId = await resolveCopilotSessionId(repoRoot, branch).catch(
+			() => null,
+		);
+		if (copilotSessionId && SESSION_ID_RE.test(copilotSessionId)) {
+			return copilotSessionId;
+		}
+		return null;
+	}
+
 	// Strategy 1: tool-usage.jsonl
 	const toolLog = join(repoRoot, ".claude", "logs", "tool-usage.jsonl");
 	if (existsSync(toolLog)) {
@@ -322,9 +522,10 @@ export async function collectMetrics(
 	const sessionStart =
 		(await readSessionStart(root)) ?? (await getBranchStartTime(root));
 
-	const [attributions, minimapTotals] = await Promise.all([
+	const [attributions, minimapTotals, prDiffStats] = await Promise.all([
 		getBranchAttribution(root, sessionStart),
 		getMinimapTotals(root),
+		getBranchDiffStats(root),
 	]);
 
 	// Last-wins per file for attribution
@@ -420,9 +621,10 @@ export async function collectMetrics(
 		)
 		.map(([id]) => id);
 	const primarySessionId =
+		orderedSessionIds.find((id) => transcriptsBySession.has(id)) ??
 		(SESSION_ID_RE.test(sessionId) && transcriptsBySession.has(sessionId)
 			? sessionId
-			: orderedSessionIds.find((id) => transcriptsBySession.has(id))) ?? null;
+			: null);
 	const transcript = primarySessionId
 		? transcriptsBySession.get(primarySessionId) ?? null
 		: null;
@@ -439,6 +641,7 @@ export async function collectMetrics(
 		lastSeenByFile,
 		allTranscripts,
 		minimapTotals,
+		prDiffStats,
 	};
 }
 
@@ -528,6 +731,7 @@ export function renderMetrics(data: MetricsData): string {
 		lastSeenByFile,
 		allTranscripts,
 		minimapTotals,
+		prDiffStats,
 	} = data;
 
 	const lines: string[] = [];
@@ -555,18 +759,16 @@ export function renderMetrics(data: MetricsData): string {
 		out(
 			`**Codebase: ~${minimapTotals.pctAi}% AI** (${minimapTotals.ai} / ${minimapTotals.total} lines)`,
 		);
-		if (hasAttribution) {
-			const {
-				ai: prAi,
-				total: prTotal,
-				pctAi: prPctAi,
-			} = aggregateTotals(allFileStats);
+		const fallbackPrStats = hasAttribution ? aggregateTotals(allFileStats) : null;
+		const effectivePrStats = prDiffStats ?? fallbackPrStats;
+		if (effectivePrStats) {
+			const { ai: prAi, total: prTotal, pctAi: prPctAi } = effectivePrStats;
 			const codebasePct =
 				minimapTotals.total > 0
 					? Math.round((prTotal / minimapTotals.total) * 100)
 					: 0;
 			out(
-				`**This PR:** ${prTotal} lines changed (${codebasePct}% of codebase) · ${prPctAi}% AI edits · ${prAi} AI lines`,
+				`**This PR:** ${prTotal} lines changed (${codebasePct}% of codebase) · ${prPctAi}% AI edits · ${prAi} AI-attributed changed lines`,
 			);
 		}
 		out();