claude-attribution 1.9.4 → 1.9.6

package/src/attribution/git-notes.ts

@@ -22,10 +22,14 @@ import {
 
 const execFileAsync = promisify(execFile);
 export const NOTES_REF = "refs/notes/claude-attribution";
+const GIT_OUTPUT_MAX_BUFFER = 10 * 1024 * 1024;
 
 /** Run a shell command and return trimmed stdout. Throws on non-zero exit. */
 async function run(cmd: string, args: string[], cwd?: string): Promise<string> {
-	const { stdout } = await execFileAsync(cmd, args, { cwd });
+	const { stdout } = await execFileAsync(cmd, args, {
+		cwd,
+		maxBuffer: GIT_OUTPUT_MAX_BUFFER,
+	});
 	return stdout.trim();
 }
 
@@ -35,7 +39,10 @@ async function runRaw(
 	args: string[],
 	cwd?: string,
 ): Promise<string> {
-	const { stdout } = await execFileAsync(cmd, args, { cwd });
+	const { stdout } = await execFileAsync(cmd, args, {
+		cwd,
+		maxBuffer: GIT_OUTPUT_MAX_BUFFER,
+	});
 	return stdout;
 }
 
@@ -323,7 +330,7 @@ function inferAiActorRuntime(meta: CommitMeta): AssistantRuntimeInfo | undefined
 
 /**
  * Build a 100% AI AttributionResult for a commit without running the
- * checkpoint-based differ. All non-blank committed lines are marked AI.
+ * checkpoint-based differ. All committed lines are marked AI.
  *
  * Used by `note-ai-commit` (to write git notes in GHA) and by `collect.ts`
  * (to synthesize attribution at metrics time for unattributed AI actor commits).
@@ -343,8 +350,8 @@ export async function buildAllAiResult(
 				const content = await committedContentAt(repoRoot, sha, relPath);
 				if (content === null || content.includes("\0")) return null;
 				const lines = content.split("\n");
-				const ai = lines.filter((l) => l.trim().length > 0).length;
-				const human = lines.length - ai;
+				const ai = lines.length;
+				const human = 0;
 				const total = lines.length;
 				return {
 					path: relPath,

package/src/attribution/minimap.ts

@@ -23,9 +23,11 @@ import { writeFile, unlink, mkdtemp, rmdir } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import { hashLine } from "./differ.ts";
+import { committedContentAt } from "./git-notes.ts";
 
 const execFileAsync = promisify(execFile);
 const BLANK_LINE_HASH = hashLine("");
+const GIT_OUTPUT_MAX_BUFFER = 10 * 1024 * 1024;
 
 export const MINIMAP_NOTES_REF = "refs/notes/claude-attribution-map";
 
@@ -47,7 +49,10 @@ export interface MinimapResult {
 }
 
 async function run(cmd: string, args: string[], cwd?: string): Promise<string> {
-	const { stdout } = await execFileAsync(cmd, args, { cwd });
+	const { stdout } = await execFileAsync(cmd, args, {
+		cwd,
+		maxBuffer: GIT_OUTPUT_MAX_BUFFER,
+	});
 	return stdout.trim();
 }
 
@@ -169,6 +174,102 @@ export async function readMinimap(
 	}
 }
 
+async function commitParents(
+	repoRoot: string,
+	commitSha: string,
+): Promise<string[]> {
+	const output = await run(
+		"git",
+		["rev-list", "--parents", "-n", "1", commitSha],
+		repoRoot,
+	).catch(() => "");
+	const parts = output.split(" ").filter(Boolean);
+	return parts.slice(1);
+}
+
+async function trackedFilesAt(
+	repoRoot: string,
+	commitSha: string,
+): Promise<string[]> {
+	const output = await run(
+		"git",
+		["ls-tree", "-r", "--name-only", commitSha],
+		repoRoot,
+	).catch(() => "");
+	return output ? output.split("\n").filter(Boolean) : [];
+}
+
+export async function resolveMinimap(
+	repoRoot: string,
+	commitSha = "HEAD",
+	cache = new Map<string, Promise<MinimapResult | null>>(),
+): Promise<MinimapResult | null> {
+	const cached = cache.get(commitSha);
+	if (cached) return cached;
+
+	const pending = (async (): Promise<MinimapResult | null> => {
+		const direct = await readMinimap(repoRoot, commitSha);
+		if (direct) return direct;
+
+		const parents = await commitParents(repoRoot, commitSha);
+		if (parents.length === 0) return null;
+
+		const parentMinimaps = (
+			await Promise.all(parents.map((parent) => resolveMinimap(repoRoot, parent, cache)))
+		).filter((result): result is MinimapResult => result !== null);
+		if (parentMinimaps.length === 0) return null;
+
+		const inheritedAiByPath = new Map<string, Set<string>>();
+		for (const parent of parentMinimaps) {
+			for (const file of parent.files) {
+				let combined = inheritedAiByPath.get(file.path);
+				if (!combined) {
+					combined = new Set<string>();
+					inheritedAiByPath.set(file.path, combined);
+				}
+				for (const hash of hashSetFromString(file.ai_hashes)) {
+					combined.add(hash);
+				}
+			}
+		}
+
+		const allFiles = await trackedFilesAt(repoRoot, commitSha);
+		const minimapFiles: MinimapFileState[] = [];
+		for (let i = 0; i < allFiles.length; i += CONCURRENCY) {
+			const batch = allFiles.slice(i, i + CONCURRENCY);
+			const results = await Promise.all(
+				batch.map(async (relPath): Promise<MinimapFileState> => {
+					const committed = await committedContentAt(repoRoot, commitSha, relPath).catch(
+						() => null,
+					);
+					if (!committed || committed.includes("\0")) {
+						return {
+							path: relPath,
+							ai_hashes: "",
+							ai: 0,
+							human: 0,
+							total: 0,
+							pctAi: 0,
+						};
+					}
+					return computeMinimapFile(
+						relPath,
+						committed.split("\n"),
+						new Set<string>(),
+						inheritedAiByPath.get(relPath) ?? new Set<string>(),
+					);
+				}),
+			);
+			minimapFiles.push(...results);
+		}
+
+		return buildResult(commitSha, minimapFiles);
+	})();
+
+	cache.set(commitSha, pending);
+	return pending;
+}
+
 export async function listMinimapNotes(repoRoot: string): Promise<string[]> {
 	try {
 		const output = await run(

package/src/commands/note-ai-commit.ts

@@ -12,8 +12,8 @@
  *                   by a known AI actor (bot author or Co-authored-by trailer).
  *                   Silent no-op otherwise — safe to run on every push.
  *
- * All non-blank lines in the committed files are attributed as AI. Blank
- * lines are always HUMAN per the attribution algorithm in differ.ts.
+ * All committed lines in the changed files are attributed as AI, including
+ * blank lines.
  */
 import { resolve } from "path";
 import {

package/src/export/merge-pr-artifacts.ts

@@ -0,0 +1,271 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import {
+	aggregateTotals,
+	type AssistantRuntimeInfo,
+	type AttributionResult,
+	type CommitModelUsage,
+	type CommitSessionMetrics,
+} from "../attribution/differ.ts";
+import {
+	NOTES_REF,
+	committedContentAt,
+	renamedFilesInCommit,
+	writeNote,
+} from "../attribution/git-notes.ts";
+import {
+	MINIMAP_NOTES_REF,
+	computeMinimapFile,
+	hashSetFromString,
+	resolveMinimap,
+	type MinimapResult,
+	type MinimapFileState,
+	writeMinimap,
+} from "../attribution/minimap.ts";
+import { pushNotesRefs } from "../attribution/notes-sync.ts";
+
+const execFileAsync = promisify(execFile);
+
+interface WriteMergedPrArtifactsOptions {
+	repoRoot: string;
+	mergeCommitSha: string;
+	prHeadSha: string;
+	results: AttributionResult[];
+	baseRef?: string | null;
+	push?: boolean;
+}
+
+async function runGit(repoRoot: string, args: string[]): Promise<string> {
+	const { stdout } = await execFileAsync("git", args, { cwd: repoRoot });
+	return stdout.trim();
+}
+
+async function trackedFilesAt(repoRoot: string, commitSha: string): Promise<string[]> {
+	const output = await runGit(repoRoot, ["ls-tree", "-r", "--name-only", commitSha]).catch(
+		() => "",
+	);
+	return output ? output.split("\n").filter(Boolean) : [];
+}
+
+async function changedFilesInCommit(
+	repoRoot: string,
+	commitSha: string,
+): Promise<Set<string>> {
+	const output = await runGit(repoRoot, [
+		"diff-tree",
+		"--no-commit-id",
+		"-r",
+		"--name-only",
+		commitSha,
+	]).catch(() => "");
+	return new Set(output.split("\n").filter(Boolean));
+}
+
+async function firstParent(repoRoot: string, commitSha: string): Promise<string | null> {
+	const output = await runGit(repoRoot, ["rev-list", "--parents", "-n", "1", commitSha]).catch(
+		() => "",
+	);
+	const [, parent] = output.split(" ");
+	return parent ?? null;
+}
+
+function aggregateModelUsage(results: AttributionResult[]): CommitModelUsage[] {
+	const byModel = new Map<string, CommitModelUsage>();
+	for (const result of results) {
+		for (const model of result.modelUsage ?? []) {
+			const key = `${model.modelFull}|${model.modelShort}`;
+			const existing = byModel.get(key);
+			if (existing) {
+				existing.calls += model.calls;
+				existing.inputTokens += model.inputTokens;
+				existing.outputTokens += model.outputTokens;
+				existing.cacheCreationTokens += model.cacheCreationTokens;
+				existing.cacheReadTokens += model.cacheReadTokens;
+			} else {
+				byModel.set(key, { ...model });
+			}
+		}
+	}
+	return [...byModel.values()].sort((a, b) =>
+		a.modelFull.localeCompare(b.modelFull),
+	);
+}
+
+function aggregateSessionMetrics(
+	results: AttributionResult[],
+): CommitSessionMetrics | undefined {
+	const toolCounts: Record<string, number> = {};
+	const agentCounts: Record<string, number> = {};
+	const skillNames = new Set<string>();
+	let humanPromptCount = 0;
+	let activeMinutes = 0;
+	let aiMinutes = 0;
+	let humanMinutes = 0;
+	let hasAny = false;
+
+	for (const result of results) {
+		const metrics = result.sessionMetrics;
+		if (!metrics) continue;
+		hasAny = true;
+		for (const [tool, count] of Object.entries(metrics.toolCounts ?? {})) {
+			toolCounts[tool] = (toolCounts[tool] ?? 0) + count;
+		}
+		for (const [agent, count] of Object.entries(metrics.agentCounts ?? {})) {
+			agentCounts[agent] = (agentCounts[agent] ?? 0) + count;
+		}
+		for (const skill of metrics.skillNames ?? []) {
+			skillNames.add(skill);
+		}
+		humanPromptCount += metrics.humanPromptCount ?? 0;
+		activeMinutes += metrics.activeMinutes ?? 0;
+		aiMinutes += metrics.aiMinutes ?? 0;
+		humanMinutes += metrics.humanMinutes ?? 0;
+	}
+
+	if (!hasAny) return undefined;
+	return {
+		toolCounts: Object.keys(toolCounts).length > 0 ? toolCounts : undefined,
+		agentCounts: Object.keys(agentCounts).length > 0 ? agentCounts : undefined,
+		skillNames: skillNames.size > 0 ? [...skillNames].sort() : undefined,
+		humanPromptCount,
+		activeMinutes,
+		aiMinutes,
+		humanMinutes,
+	};
+}
+
+function latestAssistantRuntime(
+	results: AttributionResult[],
+): AssistantRuntimeInfo | undefined {
+	for (let i = results.length - 1; i >= 0; i--) {
+		const runtime = results[i]?.assistantRuntime;
+		if (runtime) return runtime;
+	}
+	return undefined;
+}
+
+function buildMinimapResult(
+	commitSha: string,
+	files: MinimapFileState[],
+): MinimapResult {
+	const totals = files.reduce(
+		(acc, file) => ({
+			ai: acc.ai + file.ai,
+			human: acc.human + file.human,
+			total: acc.total + file.total,
+		}),
+		{ ai: 0, human: 0, total: 0 },
+	);
+	return {
+		commit: commitSha,
+		timestamp: new Date().toISOString(),
+		files,
+		totals: {
+			...totals,
+			pctAi: totals.total > 0 ? Math.round((totals.ai / totals.total) * 100) : 0,
+		},
+	};
+}
+
+export async function writeMergedPrArtifacts({
+	repoRoot,
+	mergeCommitSha,
+	prHeadSha,
+	results,
+	baseRef,
+	push = false,
+}: WriteMergedPrArtifactsOptions): Promise<{
+	note: AttributionResult;
+	minimap: MinimapResult | null;
+}> {
+	const sorted = [...results].sort(
+		(a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime(),
+	);
+	const lastSeenByFile = new Map<string, AttributionResult["files"][number]>();
+	for (const result of sorted) {
+		for (const file of result.files) {
+			lastSeenByFile.set(file.path, file);
+		}
+	}
+
+	const files = [...lastSeenByFile.values()].sort((a, b) =>
+		a.path.localeCompare(b.path),
+	);
+	const note: AttributionResult = {
+		commit: mergeCommitSha,
+		session: sorted.at(-1)?.session ?? null,
+		branch: baseRef ?? sorted.at(-1)?.branch ?? null,
+		timestamp: new Date().toISOString(),
+		files,
+		totals: aggregateTotals(files),
+	};
+
+	const modelUsage = aggregateModelUsage(sorted);
+	if (modelUsage.length > 0) note.modelUsage = modelUsage;
+	const sessionMetrics = aggregateSessionMetrics(sorted);
+	if (sessionMetrics) note.sessionMetrics = sessionMetrics;
+	const assistantRuntime = latestAssistantRuntime(sorted);
+	if (assistantRuntime) note.assistantRuntime = assistantRuntime;
+
+	await writeNote(note, repoRoot, mergeCommitSha);
+
+	const parentSha = await firstParent(repoRoot, mergeCommitSha);
+	const [
+		baseMinimap,
+		prHeadMinimap,
+		renamedBasePathByCurrentPath,
+		trackedFiles,
+		changedFiles,
+	] = await Promise.all([
+		parentSha ? resolveMinimap(repoRoot, parentSha) : Promise.resolve(null),
+		resolveMinimap(repoRoot, prHeadSha).catch(() => null),
+		renamedFilesInCommit(repoRoot, mergeCommitSha),
+		trackedFilesAt(repoRoot, mergeCommitSha),
+		changedFilesInCommit(repoRoot, mergeCommitSha),
+	]);
+
+	let minimap: MinimapResult | null = null;
+	if (parentSha && baseMinimap && prHeadMinimap) {
+		const baseAiByPath = new Map(
+			baseMinimap.files.map((file) => [file.path, hashSetFromString(file.ai_hashes)]),
+		);
+		const prHeadAiByPath = new Map(
+			prHeadMinimap.files.map((file) => [file.path, hashSetFromString(file.ai_hashes)]),
+		);
+
+		const minimapFiles = await Promise.all(
+			trackedFiles.map(async (path): Promise<MinimapFileState> => {
+				const committed = await committedContentAt(repoRoot, mergeCommitSha, path).catch(
+					() => null,
+				);
+				if (!committed || committed.includes("\0")) {
+					return {
+						path,
+						ai_hashes: "",
+						ai: 0,
+						human: 0,
+						total: 0,
+						pctAi: 0,
+					};
+				}
+				const basePath = renamedBasePathByCurrentPath.get(path) ?? path;
+				return computeMinimapFile(
+					path,
+					committed.split("\n"),
+					changedFiles.has(path)
+						? (prHeadAiByPath.get(path) ?? new Set<string>())
+						: new Set<string>(),
+					baseAiByPath.get(basePath) ?? new Set<string>(),
+				);
+			}),
+		);
+		minimap = buildMinimapResult(mergeCommitSha, minimapFiles);
+		await writeMinimap(minimap, repoRoot, mergeCommitSha);
+	}
+
+	if (push) {
+		await pushNotesRefs(repoRoot, [NOTES_REF, MINIMAP_NOTES_REF]);
+	}
+
+	return { note, minimap };
+}

package/src/export/pr-summary.ts

@@ -53,6 +53,7 @@ import {
 } from "../attribution/differ.ts";
 import { readMinimap } from "../attribution/minimap.ts";
 import { calculateCostUsd } from "../pricing.ts";
+import { writeMergedPrArtifacts } from "./merge-pr-artifacts.ts";
 
 // ---------------------------------------------------------------------------
 // OTLP/HTTP JSON types (subset needed for gauge metrics)
@@ -180,6 +181,8 @@ async function main() {
 	const repo = process.env.GITHUB_REPOSITORY ?? "";
 	const author = process.env.PR_AUTHOR ?? "";
 	const baseRef = process.env.GITHUB_BASE_REF ?? "main";
+	const prHeadSha = process.env.PR_HEAD_SHA ?? "";
+	const mergeCommitSha = process.env.MERGE_COMMIT_SHA ?? "";
 	const webhookUrl = process.env.METRICS_WEBHOOK_URL ?? "";
 
 	// Resolve OTLP endpoint + headers — explicit vars take precedence over Datadog shortcut
@@ -271,7 +274,26 @@ async function main() {
 	// Use branch from the most recent note; fall back to env var
 	const branch = results[results.length - 1]?.branch ?? baseRef;
 
-	const headMinimap = await readMinimap(repoRoot, "HEAD").catch(() => null);
+	const mergedArtifacts =
+		mergeCommitSha && prHeadSha
+			? await writeMergedPrArtifacts({
+					repoRoot,
+					mergeCommitSha,
+					prHeadSha,
+					results,
+					baseRef,
+					push: true,
+				}).catch((error) => {
+					console.warn(
+						`[pr-summary] Warning: failed to write merge commit notes for ${mergeCommitSha}:`,
+						error,
+					);
+					return null;
+				})
+			: null;
+
+	const headMinimap =
+		mergedArtifacts?.minimap ?? (await readMinimap(repoRoot, "HEAD").catch(() => null));
 
 	// OTLP data point attributes (shared across all metrics)
 	const timeUnixNano = String(Date.now() * 1_000_000);

package/src/metrics/collect.ts

@@ -37,6 +37,7 @@ import { SESSION_ID_RE } from "../attribution/checkpoint.ts";
 import {
 	hashSetFromString,
 	readMinimap,
+	resolveMinimap,
 	listMinimapNotes,
 } from "../attribution/minimap.ts";
 import { detectAssistantRuntime } from "../attribution/runtime.ts";
@@ -72,6 +73,12 @@ export interface MetricsData {
 		ai: number;
 		total: number;
 		pctAi: number;
+		files: Array<{
+			path: string;
+			ai: number;
+			total: number;
+			pctAi: number;
+		}>;
 	} | null;
 }
 
@@ -154,14 +161,19 @@ function parseChangedLineNumbers(diff: string): {
 
 async function getBranchDiffStats(
 	repoRoot: string,
-): Promise<{ ai: number; total: number; pctAi: number } | null> {
+): Promise<{
+	ai: number;
+	total: number;
+	pctAi: number;
+	files: Array<{ path: string; 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),
+			resolveMinimap(repoRoot, "HEAD"),
+			resolveMinimap(repoRoot, baseSha).catch(() => null),
 			execFileAsync(
 				"git",
 				["diff", "--name-only", "--find-renames", `${baseSha}..HEAD`],
@@ -197,7 +209,7 @@ async function getBranchDiffStats(
 
 	const changedFiles = changedFilesOutput.split("\n").filter(Boolean);
 	if (changedFiles.length === 0) {
-		return { ai: 0, total: 0, pctAi: 0 };
+		return { ai: 0, total: 0, pctAi: 0, files: [] };
 	}
 
 	const fileStats = await Promise.all(
@@ -238,18 +250,20 @@ async function getBranchDiffStats(
 			]);
 
 			const numstatLine = numstatResult.split("\n").find(Boolean);
-			if (!numstatLine) return { ai: 0, total: 0 };
+			if (!numstatLine) return { path, ai: 0, total: 0, pctAi: 0 };
 
 			const [additionsRaw, deletionsRaw] = numstatLine.split("\t");
-			if (!additionsRaw || !deletionsRaw) return { ai: 0, total: 0 };
+			if (!additionsRaw || !deletionsRaw) {
+				return { path, ai: 0, total: 0, pctAi: 0 };
+			}
 			if (additionsRaw === "-" || deletionsRaw === "-") {
-				return { ai: 0, total: 0 };
+				return { path, ai: 0, total: 0, pctAi: 0 };
 			}
 
 			const additions = parseInt(additionsRaw, 10);
 			const deletions = parseInt(deletionsRaw, 10);
 			const total = additions + deletions;
-			if (total === 0) return { ai: 0, total: 0 };
+			if (total === 0) return { path, ai: 0, total: 0, pctAi: 0 };
 
 			const { added, removed } = parseChangedLineNumbers(diffResult);
 			const headLines = headContent?.split("\n") ?? [];
@@ -271,7 +285,12 @@ async function getBranchDiffStats(
 				}
 			}
 
-			return { ai, total };
+			return {
+				path,
+				ai,
+				total,
+				pctAi: total > 0 ? Math.round((ai / total) * 100) : 0,
+			};
 		}),
 	);
 
@@ -286,6 +305,7 @@ async function getBranchDiffStats(
 		ai: totals.ai,
 		total: totals.total,
 		pctAi: totals.total > 0 ? Math.round((totals.ai / totals.total) * 100) : 0,
+		files: fileStats.filter((file) => file.total > 0),
 	};
 }
 
@@ -472,6 +492,11 @@ function transcriptFromAttribution(
 		agentCounts: sessionMetrics?.agentCounts ?? {},
 		provider:
 			result.assistantRuntime?.vendor === "copilot" ? "copilot" : "claude",
+		signalSource: "git-note",
+		signalSourceLabel:
+			result.assistantRuntime?.vendor === "copilot"
+				? "Git note snapshot (Copilot-derived)"
+				: "Git note snapshot (Claude-derived)",
 		costMode:
 			result.assistantRuntime?.vendor === "copilot" ? "unavailable" : "estimated",
 		costDescription:
@@ -488,8 +513,8 @@ export function kFormat(n: number): string {
 async function getMinimapTotals(
 	repoRoot: string,
 ): Promise<{ ai: number; human: number; total: number; pctAi: number } | null> {
-	// Try HEAD first (written by post-commit hook)
-	const head = await readMinimap(repoRoot, "HEAD");
+	// Try HEAD first (written by post-commit hook), then synthesize from ancestors.
+	const head = await resolveMinimap(repoRoot, "HEAD");
 	if (head) return head.totals;
 
 	// Fall back: find the most recent minimap note on the current branch
@@ -567,7 +592,7 @@ export async function collectMetrics(
 					id,
 					sessionStart ?? undefined,
 				).catch(() => []),
-				parseLocalSession(id, root).catch(() => null),
+				parseLocalSession(id, root, sessionStart).catch(() => null),
 			]);
 			return {
 				sessionId: id,
@@ -785,6 +810,10 @@ export function renderMetrics(data: MetricsData): string {
 			out(`**Session:** ${sessionLine}`);
 			out();
 		}
+		if (transcript.signalSourceLabel) {
+			out(`**Session/model source:** ${transcript.signalSourceLabel}`);
+			out();
+		}
 	}
 
 	if (runtimeSummaries.length > 0) {
@@ -871,13 +900,14 @@ export function renderMetrics(data: MetricsData): string {
 	}
 
 	// <details> block — skills, agents, notable tools, per-file breakdown
+	const prFiles = (prDiffStats?.files ?? []).filter((file) => file.total > 0);
 	const claudeFiles = [...lastSeenByFile.entries()].filter(
 		([, stats]) => stats.ai > 0 || stats.mixed > 0,
 	);
 	const hasSkills = skillNames.length > 0;
 	const hasAgents = agentCounts.size > 0;
 	const hasNotableTools = toolCounts.size > 0;
-	const hasFiles = claudeFiles.length > 0;
+	const hasFiles = prFiles.length > 0 || claudeFiles.length > 0;
 
 	const summaryParts: string[] = [];
 	if (hasSkills) summaryParts.push("Skills");
@@ -923,11 +953,20 @@ export function renderMetrics(data: MetricsData): string {
 	if (hasFiles) {
 		out("#### Files");
 		out();
-		for (const [path, stats] of claudeFiles.sort()) {
-			const filePct =
-				stats.total > 0 ? Math.round((stats.ai / stats.total) * 100) : 0;
-			const relPath = relative(repoRoot, join(repoRoot, path));
-			out(`- \`${relPath}\` — ${filePct}% AI (${stats.ai} lines)`);
+		if (prFiles.length > 0) {
+			for (const stats of [...prFiles].sort((a, b) => a.path.localeCompare(b.path))) {
+				const relPath = relative(repoRoot, join(repoRoot, stats.path));
+				out(
+					`- \`${relPath}\` — ${stats.pctAi}% AI (${stats.ai} / ${stats.total} changed lines)`,
+				);
+			}
+		} else {
+			for (const [path, stats] of claudeFiles.sort()) {
+				const filePct =
+					stats.total > 0 ? Math.round((stats.ai / stats.total) * 100) : 0;
+				const relPath = relative(repoRoot, join(repoRoot, path));
+				out(`- \`${relPath}\` — ${filePct}% AI (${stats.ai} lines)`);
+			}
 		}
 		out();
 	} else if (!hasAttribution) {