claude-attribution 1.9.4 → 1.9.5

package/package.json

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

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

@@ -102,6 +102,7 @@ describe("copilot-session", () => {
 			expect(parsed?.activeMinutes).toBe(3);
 			expect(parsed?.aiMinutes).toBe(2);
 			expect(parsed?.humanMinutes).toBe(1);
+			expect(parsed?.signalSourceLabel).toBe("Copilot session logs");
 			expect(parsed?.costMode).toBe("unavailable");
 		} finally {
 			process.env.HOME = originalHome;
@@ -138,4 +139,131 @@ describe("copilot-session", () => {
 			await ctx.cleanup();
 		}
 	});
+
+	test("scopes Copilot session metrics to the provided start time", async () => {
+		const ctx = await createTempContext("copilot-session-since");
+		const originalHome = process.env.HOME;
+		try {
+			process.env.HOME = ctx.home;
+			const sessionId = "copilot-session-2";
+			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: "Old work" },
+				},
+				{
+					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: "tool.execution_complete",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { model: "gpt-5.4" },
+				},
+				{
+					type: "user.message",
+					timestamp: "2026-04-01T11:00:00.000Z",
+					data: { content: "Current work" },
+				},
+				{
+					type: "assistant.message",
+					timestamp: "2026-04-01T11:02:00.000Z",
+					data: { outputTokens: 120 },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T11:02:00.000Z",
+				},
+				{
+					type: "tool.execution_complete",
+					timestamp: "2026-04-01T11:02:00.000Z",
+					data: { model: "gpt-5.4" },
+				},
+			]);
+
+			const parsed = await parseCopilotSession(
+				sessionId,
+				ctx.repo,
+				undefined,
+				new Date("2026-04-01T10:30:00.000Z"),
+			);
+
+			expect(parsed).not.toBeNull();
+			expect(parsed?.humanPromptCount).toBe(1);
+			expect(parsed?.activeMinutes).toBe(2);
+			expect(parsed?.aiMinutes).toBe(2);
+			expect(parsed?.humanMinutes).toBe(0);
+			expect(parsed?.totals.totalCalls).toBe(1);
+			expect(parsed?.totals.totalOutputTokens).toBe(120);
+		} finally {
+			process.env.HOME = originalHome;
+			await ctx.cleanup();
+		}
+	});
+
+	test("keeps a recent prompt as the start anchor when /start is set immediately after it", async () => {
+		const ctx = await createTempContext("copilot-session-anchor");
+		const originalHome = process.env.HOME;
+		try {
+			process.env.HOME = ctx.home;
+			const sessionId = "copilot-session-3";
+			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: "Kick off the fix" },
+				},
+				{
+					type: "assistant.message",
+					timestamp: "2026-04-01T10:02:00.000Z",
+					data: { outputTokens: 240 },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T10:02:00.000Z",
+				},
+				{
+					type: "tool.execution_complete",
+					timestamp: "2026-04-01T10:02:00.000Z",
+					data: { model: "gpt-5.4" },
+				},
+			]);
+
+			const parsed = await parseCopilotSession(
+				sessionId,
+				ctx.repo,
+				undefined,
+				new Date("2026-04-01T10:00:30.000Z"),
+			);
+
+			expect(parsed).not.toBeNull();
+			expect(parsed?.humanPromptCount).toBe(1);
+			expect(parsed?.activeMinutes).toBe(2);
+			expect(parsed?.aiMinutes).toBe(2);
+			expect(parsed?.humanMinutes).toBe(0);
+		} finally {
+			process.env.HOME = originalHome;
+			await ctx.cleanup();
+		}
+	});
 });

package/src/__tests__/differ.test.ts

@@ -98,14 +98,28 @@ describe("attributeLines — basic classification", () => {
 		expect(stats.pctAi).toBe(67);
 	});
 
-	test("empty lines always → HUMAN regardless of snapshot", () => {
+	test("new blank lines in an AI-authored file count as AI", () => {
 		const before: string[] = [];
 		const after = ["", "const x = 1;", ""];
 		const committed = ["", "const x = 1;", ""];
-		const { attribution } = attributeLines(before, after, committed);
-		expect(attribution[0]).toBe("HUMAN"); // empty line
+		const { attribution, stats } = attributeLines(before, after, committed);
+		expect(attribution[0]).toBe("AI"); // new blank line
 		expect(attribution[1]).toBe("AI"); // real content Claude wrote
-		expect(attribution[2]).toBe("HUMAN"); // empty line
+		expect(attribution[2]).toBe("AI"); // new blank line
+		expect(stats.ai).toBe(3);
+		expect(stats.human).toBe(0);
+		expect(stats.pctAi).toBe(100);
+	});
+
+	test("pre-existing blank lines stay HUMAN", () => {
+		const before = ["", "const x = 1;"];
+		const after = ["", "const x = 1;", "const y = 2;"];
+		const committed = ["", "const x = 1;"];
+		const { attribution, stats } = attributeLines(before, after, committed);
+		expect(attribution[0]).toBe("HUMAN");
+		expect(attribution[1]).toBe("HUMAN");
+		expect(stats.ai).toBe(0);
+		expect(stats.human).toBe(2);
 	});
 });
 

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

@@ -65,14 +65,19 @@ expect(await listNotes(ctx.repo)).toEqual([]);
 const result = await buildAllAiResult(ctx.repo, sha);
 expect(result.commit).toBe(sha);
 expect(result.files).toHaveLength(1);
-expect(result.files[0]).toMatchObject({
-path: "ai.txt",
-ai: 2,
-human: 1,
-total: 3,
-pctAi: 67,
-});
-expect(result.totals).toMatchObject({ ai: 2, human: 1, total: 3, pctAi: 67 });
+			expect(result.files[0]).toMatchObject({
+				path: "ai.txt",
+				ai: 3,
+				human: 0,
+				total: 3,
+				pctAi: 100,
+			});
+			expect(result.totals).toMatchObject({
+				ai: 3,
+				human: 0,
+				total: 3,
+				pctAi: 100,
+			});
 
 const meta = await getCommitMeta(ctx.repo, sha);
 expect(meta.authorName).toBe("Test User");

package/src/__tests__/integration.test.ts

@@ -11,6 +11,7 @@ import {
 	type MinimapResult,
 } from "../attribution/minimap.ts";
 import { readInstalledRepoRegistry } from "../setup/installed-repos.ts";
+import { writeMergedPrArtifacts } from "../export/merge-pr-artifacts.ts";
 import {
 	CLI_BIN,
 	configureGitIdentity,
@@ -32,7 +33,7 @@ describe("integration", () => {
 		try {
 			await initGitRepo(ctx.repo);
 			const filePath = join(ctx.repo, "src.ts");
-			await writeFile(filePath, "const value = 1;\n");
+			await writeFile(filePath, "const value = 1;");
 			await commitAll(ctx.repo, "initial");
 
 			const sessionId = "session-commit-1";
@@ -44,7 +45,7 @@ describe("integration", () => {
 				sessionId,
 			);
 			await saveCheckpoint(sessionId, filePath, "before");
-			await writeFile(filePath, "const value = 2;\nconst nextValue = 3;\n");
+			await writeFile(filePath, "const value = 2;\n\nconst nextValue = 3;");
 			await saveCheckpoint(sessionId, filePath, "after");
 
 			await writeJsonl(join(ctx.repo, ".claude", "logs", "tool-usage.jsonl"), [
@@ -121,6 +122,12 @@ describe("integration", () => {
 			expect(note.sessionMetrics?.agentCounts).toEqual({ "code-review": 1 });
 			expect(note.sessionMetrics?.humanPromptCount).toBe(1);
 			expect(note.sessionMetrics?.activeMinutes).toBe(2);
+			expect(note.files.find((file) => file.path === "src.ts")).toMatchObject({
+				ai: 3,
+				human: 0,
+				total: 3,
+				pctAi: 100,
+			});
 			expect(note.assistantRuntime).toEqual({
 				vendor: "claude",
 				client: "Claude Code",
@@ -207,6 +214,9 @@ describe("integration", () => {
 			expect(metrics.stdout).toContain("**Codebase: ~100% AI**");
 			expect(metrics.stdout).toContain("**This PR:** 1 lines changed");
 			expect(metrics.stdout).toContain("**Session:** 3 prompts · 15m total (10m AI · 5m human)");
+			expect(metrics.stdout).toContain(
+				"**Session/model source:** Git note snapshot (Copilot-derived)",
+			);
 			expect(metrics.stdout).toContain(
 				"**Assistant runtime:** GitHub Copilot CLI (v1.0.14)",
 			);
@@ -313,6 +323,260 @@ describe("integration", () => {
 				"**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");
+			expect(metrics.stdout).toContain(
+				"- `README.md` — 100% AI (2 / 2 changed lines)",
+			);
+			expect(metrics.stdout).not.toContain("- `README.md` — 2% AI (2 lines)");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("metrics preserves AI carry-forward when the branch base is a merge commit without a minimap note", async () => {
+		const ctx = await createTempContext("claude-attribution-merge-minimap");
+		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 filePath = join(ctx.repo, "app.ts");
+			await writeFile(filePath, "one\n");
+			await commitAll(ctx.repo, "base");
+			const baseSha = await currentSha(ctx.repo);
+			await writeMinimap(
+				{
+					commit: baseSha,
+					timestamp: "2026-04-01T10:00:00.000Z",
+					files: [
+						{
+							path: "app.ts",
+							ai_hashes: "",
+							ai: 0,
+							human: 2,
+							total: 2,
+							pctAi: 0,
+						},
+					],
+					totals: { ai: 0, human: 2, total: 2, pctAi: 0 },
+				},
+				ctx.repo,
+				baseSha,
+			);
+			await runCommand("git", ["push", "-u", "origin", "main"], { cwd: ctx.repo });
+
+			await runCommand("git", ["checkout", "-b", "feature/base-ai"], {
+				cwd: ctx.repo,
+			});
+			await writeFile(filePath, "one\ntwo\n");
+			await commitAll(ctx.repo, "ai base");
+			const aiBaseSha = await currentSha(ctx.repo);
+			await writeMinimap(
+				{
+					commit: aiBaseSha,
+					timestamp: "2026-04-01T10:05:00.000Z",
+					files: [
+						{
+							path: "app.ts",
+							ai_hashes: hashSetToString(new Set([hashLine("two")])),
+							ai: 1,
+							human: 2,
+							total: 3,
+							pctAi: 33,
+						},
+					],
+					totals: { ai: 1, human: 2, total: 3, pctAi: 33 },
+				},
+				ctx.repo,
+				aiBaseSha,
+			);
+
+			await runCommand("git", ["checkout", "main"], { cwd: ctx.repo });
+			await runCommand("git", ["merge", "--no-ff", "feature/base-ai", "-m", "merge ai"], {
+				cwd: ctx.repo,
+			});
+			await runCommand("git", ["push", "origin", "main"], { cwd: ctx.repo });
+
+			await runCommand("git", ["checkout", "-b", "feature/followup"], {
+				cwd: ctx.repo,
+			});
+			await writeCopilotSession(ctx.home, "merge-session-1", [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T10:10:00.000Z",
+					data: {
+						context: {
+							cwd: ctx.repo,
+							gitRoot: ctx.repo,
+							branch: "feature/followup",
+						},
+					},
+				},
+			]);
+			await mkdir(join(ctx.repo, ".claude", "attribution-state"), {
+				recursive: true,
+			});
+			await writeFile(
+				join(ctx.repo, ".claude", "attribution-state", "current-session"),
+				"merge-session-1",
+			);
+			await saveCheckpoint("merge-session-1", filePath, "before");
+			await writeFile(filePath, "one\ntwo\nthree\n");
+			await saveCheckpoint("merge-session-1", filePath, "after");
+			await runCommand("git", ["add", "app.ts"], { cwd: ctx.repo });
+			await runCommand("git", ["commit", "-m", "followup"], { cwd: ctx.repo });
+
+			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 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("**Codebase: ~50% AI** (2 / 4 lines)");
+			expect(metrics.stdout).toContain(
+				"**This PR:** 1 lines changed (25% of codebase) · 100% AI edits · 1 AI-attributed changed lines",
+			);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("merged PR helper preserves AI minimap on squash merge commits", async () => {
+		const ctx = await createTempContext("claude-attribution-squash-merge");
+		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,
+			});
+
+			await writeFile(join(ctx.repo, "app.ts"), "one\n");
+			await commitAll(ctx.repo, "base");
+			const baseSha = await currentSha(ctx.repo);
+			await writeMinimap(
+				{
+					commit: baseSha,
+					timestamp: "2026-04-03T09:00:00.000Z",
+					files: [
+						{
+							path: "app.ts",
+							ai_hashes: hashSetToString(
+								new Set([hashLine("one"), hashLine("")]),
+							),
+							ai: 2,
+							human: 0,
+							total: 2,
+							pctAi: 100,
+						},
+					],
+					totals: { ai: 2, human: 0, total: 2, pctAi: 100 },
+				},
+				ctx.repo,
+				baseSha,
+			);
+			await runCommand("git", ["push", "-u", "origin", "main"], { cwd: ctx.repo });
+
+			await runCommand("git", ["checkout", "-b", "feature/ai-change"], {
+				cwd: ctx.repo,
+			});
+			await writeFile(join(ctx.repo, "app.ts"), "one\ntwo\n");
+			await commitAll(ctx.repo, "feature work");
+			const headSha = await currentSha(ctx.repo);
+
+			const featureNote: AttributionResult = {
+				commit: headSha,
+				session: "session-squash-merge-1",
+				branch: "feature/ai-change",
+				timestamp: "2026-04-03T09:05:00.000Z",
+				files: [
+					{
+						path: "app.ts",
+						ai: 3,
+						human: 0,
+						mixed: 0,
+						total: 3,
+						pctAi: 100,
+					},
+				],
+				totals: { ai: 3, human: 0, mixed: 0, total: 3, pctAi: 100 },
+			};
+			await writeNote(featureNote, ctx.repo, headSha);
+			await writeMinimap(
+				{
+					commit: headSha,
+					timestamp: "2026-04-03T09:05:00.000Z",
+					files: [
+						{
+							path: "app.ts",
+							ai_hashes: hashSetToString(
+								new Set([hashLine("one"), hashLine("two"), hashLine("")]),
+							),
+							ai: 3,
+							human: 0,
+							total: 3,
+							pctAi: 100,
+						},
+					],
+					totals: { ai: 3, human: 0, total: 3, pctAi: 100 },
+				},
+				ctx.repo,
+				headSha,
+			);
+
+			await runCommand("git", ["checkout", "main"], { cwd: ctx.repo });
+			await runCommand("git", ["merge", "--squash", "feature/ai-change"], {
+				cwd: ctx.repo,
+			});
+			await commitAll(ctx.repo, "squash merge feature");
+			const mergeSha = await currentSha(ctx.repo);
+
+			const before = await runCommand(
+				"git",
+				["notes", "--ref", "refs/notes/claude-attribution-map", "show", mergeSha],
+				{ cwd: ctx.repo },
+			).catch(() => null);
+			expect(before).toBeNull();
+
+			await writeMergedPrArtifacts({
+				repoRoot: ctx.repo,
+				mergeCommitSha: mergeSha,
+				prHeadSha: headSha,
+				results: [featureNote],
+				baseRef: "main",
+			});
+
+			const mergedMinimap = JSON.parse(
+				(
+					await runCommand(
+						"git",
+						["notes", "--ref", "refs/notes/claude-attribution-map", "show", mergeSha],
+						{ cwd: ctx.repo },
+					)
+				).stdout,
+			) as MinimapResult;
+			expect(mergedMinimap.totals.pctAi).toBe(100);
+			expect(mergedMinimap.files.find((file) => file.path === "app.ts")?.human).toBe(
+				0,
+			);
 		} finally {
 			await ctx.cleanup();
 		}
@@ -579,7 +843,7 @@ describe("integration", () => {
 			);
 			await writeFile(
 				join(ctx.repo, "agent.ts"),
-				"export const generated = true;\n",
+				"export const generated = true;",
 			);
 			await commitAll(
 				ctx.repo,
@@ -592,9 +856,9 @@ describe("integration", () => {
 			});
 
 			expect(metrics.stdout).toContain("## AI Coding Metrics");
-			expect(metrics.stdout).toContain("**AI contribution: ~50%**");
+			expect(metrics.stdout).toContain("**AI contribution: ~100%**");
 			expect(metrics.stdout).toContain("**Assistant runtime:** GitHub Copilot");
-			expect(metrics.stdout).toContain("`agent.ts` — 50% AI (1 lines)");
+			expect(metrics.stdout).toContain("`agent.ts` — 100% AI (1 lines)");
 			expect(metrics.stdout).not.toContain("**Estimated cost:**");
 		} finally {
 			await ctx.cleanup();

package/src/attribution/commit.ts

@@ -59,7 +59,7 @@ import {
 import {
 	computeMinimapFile,
 	hashSetFromString,
-	readMinimap,
+	resolveMinimap,
 	writeMinimap,
 	MINIMAP_NOTES_REF,
 	type MinimapFileState,
@@ -140,6 +140,23 @@ async function resolveSessionForCommit(
 	return await resolveCopilotSessionId(repoRoot, branch).catch(() => null);
 }
 
+async function readSessionStart(repoRoot: string): Promise<Date | null> {
+	const markerPath = join(
+		repoRoot,
+		".claude",
+		"attribution-state",
+		"session-start",
+	);
+	if (!existsSync(markerPath)) return null;
+	try {
+		const raw = await readFile(markerPath, "utf8");
+		const marker = JSON.parse(raw) as { timestamp?: string };
+		return marker.timestamp ? new Date(marker.timestamp) : null;
+	} catch {
+		return null;
+	}
+}
+
 function mergeAssistantRuntime(
 	runtime: AssistantRuntimeInfo | undefined,
 	provider: "claude" | "copilot" | undefined,
@@ -263,15 +280,18 @@ async function main() {
 
 	// Attach session usage metadata (non-fatal if unavailable)
 	if (sessionId) {
+		const sessionStart = await readSessionStart(repoRoot);
 		const [tx, toolEntries, agentEntries] = await Promise.all([
-			parseLocalSession(sessionId, repoRoot).catch(() => null),
+			parseLocalSession(sessionId, repoRoot, sessionStart).catch(() => null),
 			readJsonlForSession<ToolLogEntry>(
 				join(repoRoot, ".claude", "logs", "tool-usage.jsonl"),
 				sessionId,
+				sessionStart ?? undefined,
 			).catch(() => []),
 			readJsonlForSession<AgentActivityEntry>(
 				join(repoRoot, ".claude", "logs", "agent-activity.jsonl"),
 				sessionId,
+				sessionStart ?? undefined,
 			).catch(() => []),
 		]);
 		const mergedRuntime = mergeAssistantRuntime(
@@ -308,9 +328,7 @@ async function main() {
 	try {
 		// Load parent commit's minimap for carry-forward (parentSha fetched at top of main)
 
-		const prevMinimap = parentSha
-			? await readMinimap(repoRoot, parentSha)
-			: null;
+		const prevMinimap = parentSha ? await resolveMinimap(repoRoot, parentSha) : null;
 
 		// Build lookup: file path → Set of AI hashes from previous minimap
 		const prevAiByFile = new Map<string, Set<string>>();

package/src/attribution/differ.ts

@@ -92,7 +92,9 @@ export function hashLine(line: string): string {
  *  - HUMAN: everything else (existed before Claude, or written after Claude
  *           finished without a checkpoint)
  *
- * Empty lines are attributed as HUMAN — they carry no signal.
+ * Blank lines follow the same hash-based rules as any other line. This means a
+ * newly introduced blank line is attributed as AI when it appears in `after`
+ * but not `before`, while pre-existing blank lines remain HUMAN.
  *
  * **Identical-line limitation**: This algorithm is set-based. If Claude and a
  * human both write a line with the same trimmed content (e.g., a closing `}`),
@@ -120,9 +122,6 @@ export function attributeLines(
 	const attribution: LineAttribution[] = committedLines.map((line) => {
 		const hash = hashLine(line);
 
-		// Blank lines carry no signal
-		if (line.trim() === "") return "HUMAN";
-
 		if (afterHashes.has(hash) && !beforeHashes.has(hash)) {
 			return "AI";
 		}

package/src/attribution/git-notes.ts

@@ -323,7 +323,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 +343,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,