claude-attribution 1.0.2 → 1.1.0

package/README.md

@@ -6,13 +6,13 @@
 > ```bash
 > npm install -g claude-attribution
 > claude-attribution install ~/Code/your-repo
-> git add .claude/settings.json .gitignore && git commit -m "chore: install claude-attribution hooks"
+> git add .claude/settings.json .github/workflows/claude-attribution-pr.yml .gitignore && git commit -m "chore: install claude-attribution hooks"
 > ```
-> From then on, just work normally. After each `git commit` you'll see a one-line attribution summary in your terminal. When you're ready to open a PR, run `/pr` in Claude Code (or `claude-attribution pr "feat: your title"`) — it fills in the metrics automatically, no copy-paste needed.
+> From then on, just work normally. After each `git commit` you'll see a one-line attribution summary in your terminal. When you open a PR — whether Claude creates it or you run `gh pr create` yourself — metrics are injected into the PR body automatically, no command needed.
 >
-> **Using Copilot?** The tool still works for tracking Claude usage alongside Copilot. Copilot line-level attribution isn't supported yet — for Copilot-specific stats, use the [GitHub Copilot usage dashboard](https://github.com/organizations/DTS-Productivity-Engineering/settings/copilot/seat_management). Both tools' org-level data flows into the VP Datadog dashboard automatically on every PR merge.
+> **Using Copilot?** The tool still works for tracking Claude usage alongside Copilot. Copilot line-level attribution isn't supported yet — for Copilot-specific stats, use the GitHub Copilot usage dashboard under your organization's Settings → Copilot. Both tools' org-level data flows into the VP Datadog dashboard automatically on every PR merge.
 >
-> **Requirements:** [Bun](https://bun.sh) (preferred) or Node 18+, and `gh` (GitHub CLI) authenticated for the `/pr` command.
+> **Requirements:** [Bun](https://bun.sh) (preferred) or Node 18+, and `gh` (GitHub CLI) authenticated.
 
 ---
 
@@ -56,20 +56,23 @@ claude-attribution install ~/Code/your-repo
 bun ~/Code/claude-attribution/src/setup/install.ts ~/Code/your-repo
 ```
 
-The installer makes four changes to the target repo:
+The installer makes six changes to the target repo:
 
-**`.claude/settings.json`** — merges five Claude Code hooks:
+**`.claude/settings.json`** — merges six Claude Code hooks:
 
 | Event | Hook | What it does |
 |-------|------|--------------|
 | PreToolUse (Edit/Write/MultiEdit/NotebookEdit) | `pre-tool-use.ts` | Snapshot file content before Claude touches it |
 | PostToolUse (all tools) | `post-tool-use.ts` | Snapshot file after Claude writes + log tool call |
+| PostToolUse (Bash) | `post-bash.ts` | Detect `gh pr create` and inject metrics into the new PR |
 | SubagentStart / SubagentStop | `subagent.ts` | Log subagent activity |
 | Stop | `stop.ts` | No-op; registered for future use |
 
 **`.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.
 
-**`.git/hooks/pre-push`** — pushes `refs/notes/claude-attribution` to origin whenever you push, so GitHub Actions can read the notes on PR merge. The installer also runs `git config --add remote.origin.push refs/notes/claude-attribution:refs/notes/claude-attribution` so `git push origin` includes notes automatically.
+**`remote.origin.push` refspec** — the installer runs `git config --add remote.origin.push refs/notes/claude-attribution:refs/notes/claude-attribution` so that `git push` (without an explicit refspec) automatically includes attribution notes. No pre-push hook is installed — a hook that pushes notes concurrently with the main push causes SSH connection conflicts on GitHub.
+
+**`.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).
 
 **`.claude/commands/`** — installs two slash commands:
 - `/metrics` — generate a PR metrics report
@@ -79,11 +82,11 @@ The installer makes four changes to the target repo:
 
 ### Committing the settings change
 
-The `.claude/settings.json` change should be committed to the repo so all developers get the hooks automatically. The `.git/hooks/post-commit` hook is local only (`.git/` is not committed) — each developer runs the installer once.
+The `.claude/settings.json` and workflow changes should be committed so all developers get the hooks and all PRs get metrics automatically.
 
 ```bash
 # After running the installer:
-git add .claude/settings.json .gitignore
+git add .claude/settings.json .github/workflows/claude-attribution-pr.yml .gitignore
 git commit -m "chore: install claude-attribution hooks"
 ```
 
@@ -111,7 +114,7 @@ claude-attribution uninstall ~/Code/your-repo
 bun ~/Code/claude-attribution/src/setup/uninstall.ts ~/Code/your-repo
 ```
 
-This removes hooks from `.claude/settings.json`, removes `.git/hooks/post-commit` and `.git/hooks/pre-push`, and removes the `/metrics` and `/start` slash commands. Attribution state (`.claude/attribution-state/`) and logs (`.claude/logs/`) are left in place.
+This removes hooks from `.claude/settings.json`, removes `.git/hooks/post-commit`, removes the slash commands, removes `.github/workflows/claude-attribution-pr.yml`, 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.
 
 ---
 
@@ -137,24 +140,49 @@ When you check out a new branch for a new ticket, run `/start` in Claude Code:
 
 This writes a timestamp to `.claude/attribution-state/session-start`. The `/metrics` command uses this to scope tool counts, token usage, and attribution data to only the activity after this marker — so a long-running Claude Code session doesn't inflate metrics across multiple tickets.
 
-### Creating a PR with metrics
+### Getting metrics into your PR
 
-When you're ready to create a PR, use the `/pr` slash command in Claude Code. It collects metrics and creates the PR in one step — no copy-paste needed:
+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).
+
+**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 looks like:
+
+```markdown
+## Claude Code Metrics
+
+**AI contribution: ~77%** (142 of 184 committed lines) · Active: 8m
+
+| Model | Calls | Input | Output | Cache |
+|-------|-------|-------|--------|-------|
+| Sonnet | 45 | 120K | 35K | 10K |
+| **Total** | 45 | 120K | 35K | 10K |
+
+**Human prompts (steering effort):** 12
+
+<details>
+<summary>Tools · Agents · Files</summary>
+
+**Tools:** Edit ×47, Read ×31, Bash ×12
+...
+</details>
 ```
-/pr "feat: COMM-1234 add user authentication"
-```
 
-Or run directly:
+#### Manual option
+
+If you need to create a PR with metrics outside of Claude, use the `/pr` slash command or CLI directly:
 
 ```bash
 claude-attribution pr "feat: COMM-1234 add user authentication"
-claude-attribution pr "feat: my feature" --draft          # Open as draft
-claude-attribution pr "feat: my feature" --base develop   # Different base branch
-claude-attribution pr                                      # Title from branch name
+claude-attribution pr "feat: my feature" --draft
+claude-attribution pr "feat: my feature" --base develop
 ```
 
-This reads `.github/PULL_REQUEST_TEMPLATE.md` if it exists, injects the metrics block at a `<!-- claude-attribution metrics -->` placeholder (or appends if missing), and creates the PR via `gh`. Requires `gh` to be installed and authenticated (`gh auth status`).
+Requires `gh` to be installed and authenticated (`gh auth status`).
 
 ### Viewing metrics without creating a PR
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claude-attribution",
-	"version": "1.0.2",
+	"version": "1.1.0",
 	"description": "AI code attribution tracking for Claude Code sessions — checkpoint-based line diff approach",
 	"type": "module",
 	"bin": {

package/src/cli.ts

@@ -8,10 +8,7 @@
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { readFile } from "fs/promises";
-import { execFile } from "child_process";
-import { promisify } from "util";
 
-const execFileAsync = promisify(execFile);
 const [, , cmd, ...rest] = process.argv;
 
 // Shift argv so sub-modules see their expected args at process.argv[2]
@@ -47,43 +44,18 @@ switch (cmd) {
 			case "stop":
 				await import("./hooks/stop.ts");
 				break;
+			case "post-bash":
+				await import("./hooks/post-bash.ts");
+				break;
 			case "post-commit":
 				await import("./attribution/commit.ts");
 				break;
-			case "pre-push": {
-				// Git passes pushed refs on stdin: "<local-ref> <local-sha> <remote-ref> <remote-sha>\n..."
-				// Skip notes push for tag-only and notes pushes to avoid SSH connection conflicts.
-				const stdin = await new Promise<string>((resolve) => {
-					let data = "";
-					process.stdin.setEncoding("utf8");
-					process.stdin.on("data", (chunk: string) => (data += chunk));
-					process.stdin.on("end", () => resolve(data));
-				});
-				const isBranchPush = stdin
-					.trim()
-					.split("\n")
-					.filter(Boolean)
-					.some((line) => {
-						const remoteRef = line.split(" ")[2] ?? "";
-						return (
-							!remoteRef.startsWith("refs/tags/") &&
-							!remoteRef.startsWith("refs/notes/")
-						);
-					});
-				if (isBranchPush) {
-					try {
-						await execFileAsync("git", [
-							"push",
-							"origin",
-							"refs/notes/claude-attribution",
-						]);
-					} catch {
-						// Ignore — notes push failure must not block git push
-					}
-				}
+			case "pre-push":
+				// No-op — notes are pushed via the remote.origin.push refspec configured
+				// at install time, avoiding concurrent SSH connection conflicts.
+				// Kept for backwards compatibility with existing hook installations.
 				process.exit(0);
 				break;
-			}
 			default:
 				console.error(`Unknown hook: ${rest[0]}`);
 				process.exit(1);

package/src/hooks/post-bash.ts

@@ -0,0 +1,125 @@
+/**
+ * PostToolUse hook for Bash tool — detects `gh pr create` and injects metrics.
+ *
+ * Registered in .claude/settings.json for matcher: "Bash"
+ * Fires after every Bash tool call; exits immediately if it isn't a PR creation.
+ *
+ * When Claude runs `gh pr create`, this hook:
+ *   1. Parses the PR number from the gh output URL
+ *   2. Collects metrics (attribution + tool counts + transcript)
+ *   3. Injects the rendered metrics block into the PR body via `gh pr edit`
+ *
+ * This provides full local metrics (tokens, tools, attribution) automatically,
+ * without requiring the developer to run any command. Falls back gracefully if
+ * gh isn't installed, the URL can't be parsed, or metrics are empty.
+ */
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { resolve } from "path";
+import { writeFile, unlink } from "fs/promises";
+import { readStdin } from "../lib/hooks.ts";
+import { collectMetrics, renderMetrics } from "../metrics/collect.ts";
+
+const execFileAsync = promisify(execFile);
+
+interface HookPayload {
+	session_id: string;
+	tool_name: string;
+	tool_input: { command?: string };
+	tool_response?: unknown;
+}
+
+function extractPrUrl(response: unknown): string | null {
+	const text =
+		typeof response === "string"
+			? response
+			: typeof response === "object" &&
+					response !== null &&
+					"output" in response
+				? String((response as { output: unknown }).output)
+				: "";
+	const match = text.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/);
+	return match ? match[0] : null;
+}
+
+function prNumberFromUrl(url: string): number | null {
+	const match = url.match(/\/pull\/(\d+)$/);
+	return match ? parseInt(match[1], 10) : null;
+}
+
+async function main() {
+	const raw = await readStdin();
+	if (!raw.trim()) process.exit(0);
+
+	let payload: HookPayload;
+	try {
+		payload = JSON.parse(raw) as HookPayload;
+	} catch {
+		process.exit(0);
+	}
+
+	if (payload.tool_name !== "Bash") process.exit(0);
+
+	const command = payload.tool_input?.command ?? "";
+	if (!command.includes("gh pr create")) process.exit(0);
+
+	const prUrl = extractPrUrl(payload.tool_response);
+	if (!prUrl) process.exit(0);
+
+	const prNumber = prNumberFromUrl(prUrl);
+	if (!prNumber) process.exit(0);
+
+	try {
+		const repoRoot = resolve(process.cwd());
+		const metricsData = await collectMetrics(
+			payload.session_id || undefined,
+			repoRoot,
+		);
+		const metricsBlock = renderMetrics(metricsData);
+		if (!metricsBlock.trim()) process.exit(0);
+
+		const { stdout: prJson } = await execFileAsync("gh", [
+			"pr",
+			"view",
+			String(prNumber),
+			"--json",
+			"body",
+		]);
+		const { body = "" } = JSON.parse(prJson) as { body?: string };
+
+		const start = "<!-- claude-attribution metrics -->";
+		const end = "<!-- /claude-attribution metrics -->";
+		const block = `${start}\n${metricsBlock}\n${end}`;
+
+		let newBody: string;
+		if (body.includes(start) && body.includes(end)) {
+			const startIdx = body.indexOf(start);
+			const endIdx = body.indexOf(end) + end.length;
+			newBody = body.slice(0, startIdx) + block + body.slice(endIdx);
+		} else if (body.includes(start)) {
+			newBody = body.slice(0, body.indexOf(start)) + block;
+		} else {
+			newBody = body ? `${body}\n\n${block}` : block;
+		}
+
+		const tmpFile = `/tmp/claude-attribution-pr-body-${Date.now()}.md`;
+		await writeFile(tmpFile, newBody);
+		try {
+			await execFileAsync("gh", [
+				"pr",
+				"edit",
+				String(prNumber),
+				"--body-file",
+				tmpFile,
+			]);
+		} finally {
+			await unlink(tmpFile).catch(() => {});
+		}
+	} catch {
+		// Non-fatal — never block Claude
+	}
+
+	process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/src/metrics/collect.ts

@@ -8,6 +8,8 @@
 import { readFile } from "fs/promises";
 import { existsSync } from "fs";
 import { resolve, join, relative } from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
 import { parseTranscript, type TranscriptResult } from "./transcript.ts";
 import {
 	listNotes,
@@ -21,6 +23,8 @@ import {
 } from "../attribution/differ.ts";
 import { SESSION_ID_RE } from "../attribution/checkpoint.ts";
 
+const execFileAsync = promisify(execFile);
+
 export interface MetricsData {
 	repoRoot: string;
 	sessionId: string;
@@ -49,6 +53,30 @@ 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"]) {
+		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`],
+				{ cwd: repoRoot },
+			);
+			const firstTs = log.trim().split("\n").filter(Boolean)[0];
+			if (firstTs) return new Date(parseInt(firstTs, 10) * 1000);
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+
 async function readJsonlForSession(
 	filePath: string,
 	sessionId: string,
@@ -130,16 +158,12 @@ export async function collectMetrics(
 	const root = repoRoot ?? resolve(process.cwd());
 	const logDir = join(root, ".claude", "logs");
 
-	const sessionId = sessionIdArg ?? (await resolveSessionId(root));
-	if (!sessionId) {
-		console.error(
-			"Error: No session ID found. Logs may be empty or not yet generated.",
-		);
-		console.error("Usage: claude-attribution metrics [session-id]");
-		process.exit(1);
-	}
+	const sessionId = sessionIdArg ?? (await resolveSessionId(root)) ?? "";
 
-	const sessionStart = await readSessionStart(root);
+	// /start marker takes precedence; fall back to earliest commit on the branch
+	// so that /start is never required for correct scoping.
+	const sessionStart =
+		(await readSessionStart(root)) ?? (await getBranchStartTime(root));
 
 	const [toolEntries, agentEntries, transcript, attributions] =
 		await Promise.all([

package/src/setup/install.ts

@@ -5,14 +5,7 @@
  *
  * If no path is given, installs into the current working directory.
  */
-import {
-	readFile,
-	writeFile,
-	appendFile,
-	copyFile,
-	chmod,
-	mkdir,
-} from "fs/promises";
+import { readFile, writeFile, appendFile, chmod, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -84,65 +77,6 @@ function detectHookManager(repoRoot: string): "husky" | "lefthook" | "none" {
 	return "none";
 }
 
-async function installPrePushHook(repoRoot: string): Promise<void> {
-	const manager = detectHookManager(repoRoot);
-	const runLine = `claude-attribution hook pre-push || true`;
-
-	if (manager === "husky") {
-		const huskyHook = join(repoRoot, ".husky", "pre-push");
-		if (existsSync(huskyHook)) {
-			const existing = await readFile(huskyHook, "utf8");
-			if (!existing.includes("claude-attribution")) {
-				await writeFile(
-					huskyHook,
-					existing.trimEnd() + "\n\n# claude-attribution\n" + runLine + "\n",
-				);
-				console.log("  (appended to existing .husky/pre-push)");
-			}
-		} else {
-			await writeFile(
-				huskyHook,
-				`#!/bin/sh\n# claude-attribution\n${runLine}\n`,
-			);
-			await chmod(huskyHook, 0o755);
-		}
-		return;
-	}
-
-	if (manager === "lefthook") {
-		console.log("");
-		console.log("  ⚠️  Lefthook detected. Add this to lefthook.yml manually:");
-		console.log("  pre-push:");
-		console.log("    commands:");
-		console.log("      claude-attribution:");
-		console.log(`        run: ${runLine}`);
-		console.log("");
-		return;
-	}
-
-	// Plain git hooks
-	const hookDest = join(repoRoot, ".git", "hooks", "pre-push");
-	const rawTemplate = await readFile(
-		join(ATTRIBUTION_ROOT, "src", "setup", "templates", "pre-push.sh"),
-		"utf8",
-	);
-	if (existsSync(hookDest)) {
-		const existing = await readFile(hookDest, "utf8");
-		if (!existing.includes("claude-attribution")) {
-			await writeFile(
-				hookDest,
-				existing.trimEnd() + "\n\n# claude-attribution\n" + rawTemplate,
-			);
-			await chmod(hookDest, 0o755);
-			return;
-		}
-		// Already ours — replace
-	}
-
-	await writeFile(hookDest, rawTemplate);
-	await chmod(hookDest, 0o755);
-}
-
 async function installGitHook(repoRoot: string): Promise<void> {
 	const manager = detectHookManager(repoRoot);
 	const runLine = `claude-attribution hook post-commit || true`;
@@ -247,29 +181,30 @@ async function main() {
 	await mergeHooks(settingsPath, hooksConfig);
 	console.log("✓ Merged hooks into .claude/settings.json");
 
-	// 2. Install post-commit and pre-push git hooks
+	// 2. Install post-commit git hook
 	await installGitHook(targetRepo);
 	console.log("✓ Installed .git/hooks/post-commit");
-	await installPrePushHook(targetRepo);
-	console.log(
-		"✓ Installed .git/hooks/pre-push (pushes attribution notes to origin)",
-	);
 
-	// Ensure git push also pushes notes by default
+	// Configure git push to also push notes by default (avoids needing a separate push).
+	// Use --unset-all first so re-running install doesn't accumulate duplicate refspecs,
+	// then --add to append alongside any other user-configured push refspecs.
+	const notesRefspec =
+		"refs/notes/claude-attribution:refs/notes/claude-attribution";
 	try {
+		// Remove any existing entries for this refspec (idempotent — exits non-zero if missing, that's fine)
 		await execFileAsync(
 			"git",
-			[
-				"config",
-				"--add",
-				"remote.origin.push",
-				"refs/notes/claude-attribution:refs/notes/claude-attribution",
-			],
+			["config", "--unset-all", "remote.origin.push", notesRefspec],
+			{ cwd: targetRepo },
+		).catch(() => {
+			// exit 5 = key not found; safe to ignore
+		});
+		await execFileAsync(
+			"git",
+			["config", "--add", "remote.origin.push", notesRefspec],
 			{ cwd: targetRepo },
 		);
-		console.log(
-			"✓ Configured remote.origin.push for attribution notes refspec",
-		);
+		console.log("✓ Configured remote.origin.push to include attribution notes");
 	} catch {
 		console.log(
 			"  (skipped git config remote.origin.push — no origin remote or git unavailable)",
@@ -300,8 +235,31 @@ async function main() {
 	await writeFile(join(commandsDir, "pr.md"), prTemplate);
 	console.log("✓ Installed .claude/commands/pr.md (/pr command)");
 
+	// 4. Install GitHub Actions workflow for automatic PR metrics injection
+	const workflowsDir = join(targetRepo, ".github", "workflows");
+	await mkdir(workflowsDir, { recursive: true });
+	const workflowTemplate = await readFile(
+		join(
+			ATTRIBUTION_ROOT,
+			"src",
+			"setup",
+			"templates",
+			"pr-metrics-workflow.yml",
+		),
+		"utf8",
+	);
+	await writeFile(
+		join(workflowsDir, "claude-attribution-pr.yml"),
+		workflowTemplate,
+	);
+	console.log(
+		"✓ Installed .github/workflows/claude-attribution-pr.yml (auto-injects metrics on PR open)",
+	);
+
 	console.log("\nDone! claude-attribution is active for this repo.");
-	console.log("Use /pr in Claude Code to create a PR with metrics embedded.");
+	console.log(
+		"Commit .claude/settings.json and .github/workflows/claude-attribution-pr.yml to share with the team.",
+	);
 }
 
 main().catch((err) => {

package/src/setup/templates/hooks.json

@@ -19,6 +19,15 @@
 					"command": "claude-attribution hook post-tool-use"
 				}
 			]
+		},
+		{
+			"matcher": "Bash",
+			"hooks": [
+				{
+					"type": "command",
+					"command": "claude-attribution hook post-bash"
+				}
+			]
 		}
 	],
 	"SubagentStart": [

package/src/setup/templates/pr-metrics-workflow.yml

@@ -0,0 +1,84 @@
+name: Claude Code Attribution Metrics
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  metrics:
+    name: Claude Code Attribution Metrics
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Fetch attribution notes
+        run: git fetch origin refs/notes/claude-attribution:refs/notes/claude-attribution || true
+
+      - name: Install claude-attribution
+        run: npm install -g claude-attribution
+
+      - name: Generate metrics
+        run: claude-attribution metrics > /tmp/claude-attribution-metrics.md || true
+
+      - name: Inject metrics into PR body
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            let metrics;
+            try {
+              metrics = fs.readFileSync('/tmp/claude-attribution-metrics.md', 'utf8').trim();
+            } catch {
+              console.log('No metrics output, skipping.');
+              return;
+            }
+            if (!metrics) {
+              console.log('Empty metrics output, skipping.');
+              return;
+            }
+
+            const { data: pr } = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.payload.pull_request.number,
+            });
+
+            const body = pr.body || '';
+            const start = '<!-- claude-attribution metrics -->';
+            const end = '<!-- /claude-attribution metrics -->';
+
+            // On 'opened': skip if the local post-bash hook already injected metrics.
+            // On 'synchronize': always update to reflect new commits.
+            if (context.payload.action === 'opened' && body.includes(start) && body.includes(end)) {
+              const existing = body.slice(body.indexOf(start) + start.length, body.indexOf(end)).trim();
+              if (existing) {
+                console.log('Metrics already injected by local hook, skipping.');
+                return;
+              }
+            }
+            const block = `${start}\n${metrics}\n${end}`;
+
+            let newBody;
+            if (body.includes(start) && body.includes(end)) {
+              const startIdx = body.indexOf(start);
+              const endIdx = body.indexOf(end) + end.length;
+              newBody = body.slice(0, startIdx) + block + body.slice(endIdx);
+            } else if (body.includes(start)) {
+              newBody = body.slice(0, body.indexOf(start)) + block;
+            } else {
+              newBody = body ? `${body}\n\n${block}` : block;
+            }
+
+            await github.rest.pulls.update({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.payload.pull_request.number,
+              body: newBody,
+            });
+            console.log('Metrics injected into PR body.');

package/src/setup/uninstall.ts

@@ -163,6 +163,17 @@ async function main() {
 		console.log("  (no slash commands found)");
 	}
 
+	// 6. Remove GitHub Actions workflow
+	const workflowPath = join(
+		targetRepo,
+		".github",
+		"workflows",
+		"claude-attribution-pr.yml",
+	);
+	if (await removeFile(workflowPath)) {
+		console.log("✓ Removed .github/workflows/claude-attribution-pr.yml");
+	}
+
 	console.log("\nDone! claude-attribution has been removed from this repo.");
 	console.log(
 		"Note: .claude/logs/ and .claude/attribution-state/ are preserved.",

package/src/setup/templates/pre-push.sh

@@ -1,4 +0,0 @@
-#!/bin/sh
-# Auto-installed by claude-attribution
-# Pushes attribution git notes to origin so GitHub Actions can read them
-claude-attribution hook pre-push || true