claude-attribution 1.6.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.
 
 ---
 
@@ -135,7 +135,7 @@ The installer makes the following changes to the target repo:
 
 **`.git/hooks/post-commit`** — runs attribution after every commit. If the repo already has a `post-commit` hook from Husky or another tool, the call is appended rather than replacing it. For Lefthook repos, the installer prints the config snippet to add manually.
 
-**`remote.origin.push` refspecs** — the installer adds two refspecs so that `git push` (without an explicit refspec) automatically includes both notes refs: `refs/notes/claude-attribution` (per-commit attribution) and `refs/notes/claude-attribution-map` (cumulative minimap). No pre-push hook is installed — a hook that pushes notes concurrently with the main push causes SSH connection conflicts on GitHub.
+**Best-effort notes sync** — after each commit, the post-commit hook writes the attribution notes locally and then tries to push `refs/notes/claude-attribution` and `refs/notes/claude-attribution-map` to `origin`. The commit note now carries durable session metadata too (model usage, notable tool counts, agent counts, skills, and session timing), so PR metrics can be rebuilt in CI even when local `.claude` logs and transcripts are unavailable. If a notes push is rejected because the remote ref moved first, it fetches the remote notes ref, runs `git notes merge`, and retries the push. No `pre-push` hook or `remote.origin.push` refspec is installed, so plain `git push` does not fail just because notes metadata raced elsewhere.
 
 **`.github/workflows/claude-attribution-pr.yml`** — GitHub Actions workflow that fires on every PR open and push. Injects metrics into the PR body automatically for PRs created outside Claude (Copilot, manual `gh pr create`, GitHub UI). Skips injection if the local `post-bash` hook already injected metrics on `opened`; always updates on `synchronize` (new commits).
 
@@ -182,7 +182,21 @@ git push origin refs/notes/claude-attribution-map
 
 ### Re-installing
 
-If you reinstall `claude-attribution` globally (e.g. after upgrading), re-run the installer — it updates the absolute paths in `settings.json` and the git hook:
+If you reinstall `claude-attribution` globally (e.g. after upgrading), you can now refresh every tracked repo in one shot:
+
+```bash
+claude-attribution update
+```
+
+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:
+
+```bash
+claude-attribution update --force
+```
+
+You can still re-run the installer manually for a single repo when needed:
 
 ```bash
 claude-attribution install ~/Code/your-repo
@@ -196,7 +210,7 @@ To remove claude-attribution from a repo:
 claude-attribution uninstall ~/Code/your-repo
 ```
 
-This removes hooks from `.claude/settings.json`, removes `.git/hooks/post-commit`, removes the slash commands, removes `.github/workflows/claude-attribution-pr.yml`, `.github/workflows/claude-attribution-export.yml`, and `.github/workflows/claude-attribution-gha.yml` (if present), and removes any legacy `pre-push` hooks (for example `.husky/pre-push` or `.git/hooks/pre-push`) if present. Attribution state (`.claude/attribution-state/`) and logs (`.claude/logs/`) are left in place. The `remote.origin.push` refspec is also removed from git config.
+This removes hooks from `.claude/settings.json`, removes `.git/hooks/post-commit`, removes the slash commands, removes `.github/workflows/claude-attribution-pr.yml`, `.github/workflows/claude-attribution-export.yml`, and `.github/workflows/claude-attribution-gha.yml` (if present), and removes any legacy `pre-push` hooks (for example `.husky/pre-push` or `.git/hooks/pre-push`) if present. Attribution state (`.claude/attribution-state/`) and logs (`.claude/logs/`) are left in place. Any legacy `remote.origin.push` notes refspecs are also removed from git config. The repo is also removed from the global installed-repo registry used by `claude-attribution update`.
 
 ---
 
@@ -228,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:
 
@@ -287,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
@@ -322,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
 
@@ -353,7 +391,19 @@ Example output:
   "files": [
     { "path": "src/components/Foo.tsx", "ai": 82, "human": 10, "mixed": 2, "total": 94, "pctAi": 87 }
   ],
-  "totals": { "ai": 142, "human": 38, "mixed": 4, "total": 184, "pctAi": 77 }
+  "totals": { "ai": 142, "human": 38, "mixed": 4, "total": 184, "pctAi": 77 },
+  "modelUsage": [
+    { "modelFull": "claude-sonnet-4.5", "modelShort": "Sonnet", "calls": 12, "inputTokens": 54000, "outputTokens": 9000, "cacheCreationTokens": 3200, "cacheReadTokens": 18000 }
+  ],
+  "sessionMetrics": {
+    "toolCounts": { "WebSearch": 2, "WebFetch": 1 },
+    "agentCounts": { "code-review": 1 },
+    "skillNames": ["pr"],
+    "humanPromptCount": 6,
+    "activeMinutes": 28,
+    "aiMinutes": 18,
+    "humanMinutes": 10
+  }
 }
 ```
 
@@ -502,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 |
 |----------|---------|-------------|
@@ -515,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.
 
 
 ---
@@ -536,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.6.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__/bulk-update.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { readInstalledRepoRegistry } from "../setup/installed-repos.ts";
+import {
+	CLI_BIN,
+	REPO_ROOT,
+	commitAll,
+	createTempContext,
+	initGitRepo,
+	runCommand,
+} from "./integration-helpers.ts";
+
+describe("bulk update command", () => {
+	test("updates tracked repos and prunes missing paths", async () => {
+		const ctx = await createTempContext("claude-attribution-bulk-update");
+		try {
+			const repoA = join(ctx.root, "repo-a");
+			const repoB = join(ctx.root, "repo-b");
+			await mkdir(repoA, { recursive: true });
+			await mkdir(repoB, { recursive: true });
+			await initGitRepo(repoA);
+			await initGitRepo(repoB);
+			await writeFile(join(repoA, "README.md"), "repo a\n");
+			await writeFile(join(repoB, "README.md"), "repo b\n");
+			await commitAll(repoA, "initial");
+			await commitAll(repoB, "initial");
+
+			await runCommand(CLI_BIN, ["install", repoA], {
+				cwd: repoA,
+				env: { HOME: ctx.home },
+			});
+			await runCommand(CLI_BIN, ["install", repoB], {
+				cwd: repoB,
+				env: { HOME: ctx.home },
+			});
+
+			await writeFile(
+				join(repoA, ".claude", "attribution-state", "installed-version"),
+				"0.9.0",
+			);
+			await writeFile(
+				join(repoB, ".claude", "attribution-state", "installed-version"),
+				"0.9.0",
+			);
+
+			const registryPath = join(
+				ctx.home,
+				".claude",
+				"claude-attribution",
+				"installed-repos.json",
+			);
+			const registry = JSON.parse(await readFile(registryPath, "utf8")) as Array<{
+				path: string;
+				firstInstalledAt: string;
+				lastUpdatedAt: string;
+				installedVersion?: string;
+			}>;
+			registry.push({
+				path: join(ctx.root, "missing-repo"),
+				firstInstalledAt: new Date(0).toISOString(),
+				lastUpdatedAt: new Date(0).toISOString(),
+				installedVersion: "0.1.0",
+			});
+			await writeFile(registryPath, JSON.stringify(registry, null, 2) + "\n");
+
+			const update = await runCommand(CLI_BIN, ["update"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			expect(update.stdout).toContain("Pruned missing repo");
+			expect(update.stdout).toContain("Updated:");
+			expect(update.stdout).toContain("Summary: 2 updated, 0 already current, 1 pruned, 0 failed");
+
+			const packageVersion = JSON.parse(
+				await readFile(join(REPO_ROOT, "package.json"), "utf8"),
+			) as { version: string };
+			expect(
+				(await readFile(
+					join(repoA, ".claude", "attribution-state", "installed-version"),
+					"utf8",
+				)).trim(),
+			).toBe(packageVersion.version);
+			expect(
+				(await readFile(
+					join(repoB, ".claude", "attribution-state", "installed-version"),
+					"utf8",
+				)).trim(),
+			).toBe(packageVersion.version);
+
+			const tracked = await readInstalledRepoRegistry(ctx.home);
+			expect(tracked.map((record) => record.path).sort()).toEqual(
+				[repoA, repoB].sort(),
+			);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+});

package/src/__tests__/checkpoint.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from "bun:test";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import {
+clearCheckpoints,
+loadCheckpoint,
+readCurrentSession,
+saveCheckpoint,
+validateSessionId,
+writeCurrentSession,
+} from "../attribution/checkpoint.ts";
+import { createTempContext } from "./integration-helpers.ts";
+
+describe("checkpoint", () => {
+test("saves, loads, and clears checkpoints", async () => {
+const ctx = await createTempContext("claude-attribution-checkpoint");
+try {
+const sessionId = "session-123";
+const filePath = join(ctx.repo, "src", "file.ts");
+await mkdir(join(ctx.repo, "src"), { recursive: true });
+await writeFile(filePath, "before\nafter");
+
+await saveCheckpoint(sessionId, filePath, "before");
+const before = await loadCheckpoint(sessionId, filePath, "before");
+expect(before?.filePath).toBe(filePath);
+expect(before?.lines).toEqual(["before", "after"]);
+expect(before?.timestamp).toMatch(/T/);
+
+await writeFile(filePath, "revised");
+await saveCheckpoint(sessionId, filePath, "after");
+const after = await loadCheckpoint(sessionId, filePath, "after");
+expect(after?.lines).toEqual(["revised"]);
+
+await clearCheckpoints(sessionId);
+expect(await loadCheckpoint(sessionId, filePath, "before")).toBeNull();
+expect(await loadCheckpoint(sessionId, filePath, "after")).toBeNull();
+} finally {
+await ctx.cleanup();
+}
+});
+
+test("handles missing files and current session markers", async () => {
+const ctx = await createTempContext("claude-attribution-session-marker");
+try {
+const sessionId = "session-abc";
+const missingFile = join(ctx.repo, "missing.ts");
+
+expect(await readCurrentSession(ctx.repo)).toBeNull();
+await writeCurrentSession(ctx.repo, sessionId);
+expect(await readCurrentSession(ctx.repo)).toBe(sessionId);
+
+await saveCheckpoint(sessionId, missingFile, "before");
+const checkpoint = await loadCheckpoint(sessionId, missingFile, "before");
+expect(checkpoint?.lines).toEqual([""]);
+
+await clearCheckpoints("missing-session");
+} finally {
+await ctx.cleanup();
+}
+});
+
+test("rejects invalid session identifiers", () => {
+expect(() => validateSessionId("ok_session-1")).not.toThrow();
+expect(() => validateSessionId("../escape")).toThrow(/Invalid session_id/);
+});
+});

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;", ""];