@mesadev/agentblame 0.2.11 → 3.0.1

package/dist/agentblame.js

@@ -0,0 +1,3500 @@
+#!/usr/bin/env bun
+// @bun
+var __require = import.meta.require;
+// src/index.ts
+import * as path7 from "path";
+import * as fs7 from "fs";
+import * as os from "os";
+import { execSync as execSync2 } from "child_process";
+
+// src/blame.ts
+import * as path2 from "path";
+import * as fs2 from "fs";
+
+// src/lib/git/gitCli.ts
+import { spawn } from "child_process";
+async function runGit(cwd, args, timeoutMs = 30000) {
+  return new Promise((resolve) => {
+    const proc = spawn("git", args, {
+      cwd,
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        stdout,
+        stderr
+      });
+    });
+    proc.on("error", (err) => {
+      resolve({
+        exitCode: 1,
+        stdout,
+        stderr: err.message
+      });
+    });
+  });
+}
+async function getRepoRoot(dir) {
+  const result = await runGit(dir, ["rev-parse", "--show-toplevel"], 5000);
+  if (result.exitCode !== 0)
+    return null;
+  return result.stdout.trim() || null;
+}
+
+// src/lib/git/gitBlame.ts
+async function getBlame(repoRoot, filePath) {
+  const result = await runGit(repoRoot, ["blame", "--porcelain", filePath], 30000);
+  if (result.exitCode !== 0) {
+    throw new Error(`git blame failed: ${result.stderr}`);
+  }
+  return parseBlameOutput(filePath, result.stdout);
+}
+function parseBlameOutput(filePath, output) {
+  const lines = [];
+  const commits = new Map;
+  const rawLines = output.split(`
+`);
+  let i = 0;
+  let lineNumber = 0;
+  while (i < rawLines.length) {
+    const headerLine = rawLines[i];
+    if (!headerLine || !headerLine.match(/^[0-9a-f]{40}/)) {
+      i++;
+      continue;
+    }
+    const parts = headerLine.split(" ");
+    const sha = parts[0];
+    const origLine = parseInt(parts[1], 10);
+    lineNumber++;
+    let author = "";
+    let authorTime = new Date;
+    i++;
+    while (i < rawLines.length && !rawLines[i].startsWith("\t")) {
+      const line = rawLines[i];
+      if (line.startsWith("author ")) {
+        author = line.slice(7);
+      } else if (line.startsWith("author-time ")) {
+        authorTime = new Date(parseInt(line.slice(12), 10) * 1000);
+      }
+      i++;
+    }
+    let content = "";
+    if (i < rawLines.length && rawLines[i].startsWith("\t")) {
+      content = rawLines[i].slice(1);
+      i++;
+    }
+    if (!commits.has(sha)) {
+      commits.set(sha, { author, time: authorTime });
+    }
+    lines.push({
+      lineNumber,
+      origLine,
+      sha,
+      author,
+      authorTime,
+      content
+    });
+  }
+  return { file: filePath, lines, commits };
+}
+
+// src/lib/storage.ts
+import * as fs from "fs";
+import * as path from "path";
+import { spawn as spawn2 } from "child_process";
+async function storeSnapshot(repoRoot, content) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn2("git", ["hash-object", "-w", "--stdin"], {
+      cwd: repoRoot,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(`git hash-object failed: ${stderr}`));
+      }
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.stdin.write(content);
+    proc.stdin.end();
+  });
+}
+async function loadSnapshot(repoRoot, blobSha) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn2("git", ["cat-file", "blob", blobSha], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout);
+      } else {
+        reject(new Error(`git cat-file failed: ${stderr}`));
+      }
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function getAgentBlameGitDir(repoRoot) {
+  return path.join(repoRoot, ".git", "agentblame");
+}
+function getWorkingDir(repoRoot, baseSha) {
+  return path.join(getAgentBlameGitDir(repoRoot), "working", baseSha);
+}
+function getSnapshotsPath(repoRoot, baseSha) {
+  return path.join(getWorkingDir(repoRoot, baseSha), "snapshots.jsonl");
+}
+function getDatabasePath(repoRoot) {
+  return path.join(getAgentBlameGitDir(repoRoot), "agentblame.db");
+}
+function ensureAgentBlameDirs(repoRoot) {
+  const agentBlameDir = getAgentBlameGitDir(repoRoot);
+  const workingDir = path.join(agentBlameDir, "working");
+  if (!fs.existsSync(agentBlameDir)) {
+    fs.mkdirSync(agentBlameDir, { recursive: true });
+  }
+  if (!fs.existsSync(workingDir)) {
+    fs.mkdirSync(workingDir, { recursive: true });
+  }
+}
+function ensureWorkingDir(repoRoot, baseSha) {
+  const workingDir = getWorkingDir(repoRoot, baseSha);
+  if (!fs.existsSync(workingDir)) {
+    fs.mkdirSync(workingDir, { recursive: true });
+  }
+}
+function appendToWorkingLog(repoRoot, baseSha, entry) {
+  ensureWorkingDir(repoRoot, baseSha);
+  const logPath = getSnapshotsPath(repoRoot, baseSha);
+  const line = JSON.stringify(entry) + `
+`;
+  fs.appendFileSync(logPath, line, "utf8");
+}
+function readWorkingLog(repoRoot, baseSha) {
+  const logPath = getSnapshotsPath(repoRoot, baseSha);
+  if (!fs.existsSync(logPath)) {
+    return [];
+  }
+  const content = fs.readFileSync(logPath, "utf8");
+  const lines = content.trim().split(`
+`).filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+}
+function getSnapshotChainForFile(repoRoot, baseSha, filePath) {
+  const entries = readWorkingLog(repoRoot, baseSha);
+  return entries.filter((entry) => entry.file === filePath).map((entry) => ({
+    timestamp: entry.ts,
+    filePath: entry.file,
+    blobSha: entry.blob,
+    sessionId: entry.session,
+    type: entry.type
+  }));
+}
+function getModifiedFiles(repoRoot, baseSha) {
+  const entries = readWorkingLog(repoRoot, baseSha);
+  const files = new Set;
+  for (const entry of entries) {
+    files.add(entry.file);
+  }
+  return Array.from(files);
+}
+function cleanupWorkingDir(repoRoot, baseSha) {
+  const workingDir = getWorkingDir(repoRoot, baseSha);
+  if (fs.existsSync(workingDir)) {
+    fs.rmSync(workingDir, { recursive: true });
+  }
+}
+function getActiveBaseShas(repoRoot) {
+  const workingBaseDir = path.join(getAgentBlameGitDir(repoRoot), "working");
+  if (!fs.existsSync(workingBaseDir)) {
+    return [];
+  }
+  try {
+    return fs.readdirSync(workingBaseDir).filter((name) => {
+      const stat = fs.statSync(path.join(workingBaseDir, name));
+      return stat.isDirectory();
+    });
+  } catch {
+    return [];
+  }
+}
+async function cleanupStaleWorkingDirs(repoRoot) {
+  const baseShas = getActiveBaseShas(repoRoot);
+  const cleaned = [];
+  const kept = [];
+  for (const baseSha of baseShas) {
+    const exists = await commitExists(repoRoot, baseSha);
+    if (!exists) {
+      cleanupWorkingDir(repoRoot, baseSha);
+      cleaned.push(baseSha);
+    } else {
+      kept.push(baseSha);
+    }
+  }
+  return { cleaned, kept };
+}
+async function commitExists(repoRoot, commitSha) {
+  return new Promise((resolve) => {
+    const proc = spawn2("git", ["cat-file", "-e", commitSha], {
+      cwd: repoRoot,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    proc.on("close", (code) => {
+      resolve(code === 0);
+    });
+    proc.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+async function getGitHead(repoRoot) {
+  return new Promise((resolve) => {
+    const proc = spawn2("git", ["rev-parse", "HEAD"], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        resolve(null);
+      }
+    });
+    proc.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+async function getParentCommit(repoRoot, commitSha) {
+  return new Promise((resolve) => {
+    const proc = spawn2("git", ["rev-parse", `${commitSha}^`], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        resolve(null);
+      }
+    });
+    proc.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+async function getFileAtCommit(repoRoot, commitSha, filePath) {
+  return new Promise((resolve) => {
+    const proc = spawn2("git", ["show", `${commitSha}:${filePath}`], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout);
+      } else {
+        resolve(null);
+      }
+    });
+    proc.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+async function getRootCommit(repoRoot) {
+  return new Promise((resolve) => {
+    const proc = spawn2("git", ["rev-list", "--max-parents=0", "HEAD"], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        const commits = stdout.trim().split(`
+`);
+        resolve(commits[0] || null);
+      } else {
+        resolve(null);
+      }
+    });
+    proc.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+function readFileContent(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function captureFileSnapshot(repoRoot, baseSha, filePath, content, sessionId, type) {
+  const blobSha = await storeSnapshot(repoRoot, content);
+  const entry = {
+    ts: new Date().toISOString(),
+    file: filePath,
+    blob: blobSha,
+    session: sessionId,
+    type
+  };
+  appendToWorkingLog(repoRoot, baseSha, entry);
+  return blobSha;
+}
+
+// src/lib/trace.ts
+async function traceFileLines(repoRoot, lines, chain) {
+  if (chain.length === 0) {
+    return lines.map(() => ({ sessionId: null, confidence: 1 }));
+  }
+  const snapshotContents = [];
+  for (const snapshot of chain) {
+    const content = await loadSnapshot(repoRoot, snapshot.blobSha);
+    snapshotContents.push(content.split(`
+`));
+  }
+  const results = [];
+  for (let lineIdx = 0;lineIdx < lines.length; lineIdx++) {
+    const lineContent = lines[lineIdx];
+    let context = {
+      prev: lines[lineIdx - 1],
+      next: lines[lineIdx + 1]
+    };
+    let origin = { sessionId: null, confidence: 1 };
+    for (let i = chain.length - 1;i >= 0; i--) {
+      const snapshotLines = snapshotContents[i];
+      const match = findLineWithContext(lineContent, context, snapshotLines);
+      if (match === null) {
+        const introducer = chain[i + 1];
+        origin = {
+          sessionId: introducer?.sessionId || null,
+          confidence: 1
+        };
+        break;
+      }
+      context = {
+        prev: snapshotLines[match.index - 1],
+        next: snapshotLines[match.index + 1]
+      };
+    }
+    results.push(origin);
+  }
+  return results;
+}
+function findLineWithContext(target, context, lines) {
+  const matches = findExactMatches(target, lines);
+  if (matches.length === 0) {
+    const normMatches = findNormalizedMatches(target, lines);
+    if (normMatches.length === 1) {
+      return { index: normMatches[0], confidence: 0.95 };
+    }
+    if (normMatches.length > 1) {
+      const contextMatch2 = findBestContextMatch(normMatches, context, lines);
+      if (contextMatch2 !== null) {
+        return { index: contextMatch2, confidence: 0.9 };
+      }
+    }
+    return null;
+  }
+  if (matches.length === 1) {
+    return { index: matches[0], confidence: 1 };
+  }
+  const contextMatch = findBestContextMatch(matches, context, lines);
+  if (contextMatch !== null) {
+    return { index: contextMatch, confidence: 1 };
+  }
+  const fuzzyMatch = findFuzzyContextMatch(matches, context, lines);
+  if (fuzzyMatch !== null) {
+    return { index: fuzzyMatch.index, confidence: fuzzyMatch.confidence };
+  }
+  return { index: matches[0], confidence: 0.5 };
+}
+function findExactMatches(target, lines) {
+  const matches = [];
+  for (let i = 0;i < lines.length; i++) {
+    if (lines[i] === target) {
+      matches.push(i);
+    }
+  }
+  return matches;
+}
+function findNormalizedMatches(target, lines) {
+  const normalizedTarget = normalizeWhitespace(target);
+  const matches = [];
+  for (let i = 0;i < lines.length; i++) {
+    if (normalizeWhitespace(lines[i]) === normalizedTarget) {
+      matches.push(i);
+    }
+  }
+  return matches;
+}
+function findBestContextMatch(candidates, context, lines) {
+  for (const idx of candidates) {
+    const prevMatch = !context.prev || lines[idx - 1] === context.prev;
+    const nextMatch = !context.next || lines[idx + 1] === context.next;
+    if (prevMatch && nextMatch) {
+      return idx;
+    }
+  }
+  for (const idx of candidates) {
+    const prevMatch = !context.prev || lines[idx - 1] === context.prev;
+    const nextMatch = !context.next || lines[idx + 1] === context.next;
+    if (prevMatch || nextMatch) {
+      return idx;
+    }
+  }
+  return null;
+}
+function findFuzzyContextMatch(candidates, context, lines) {
+  let best = null;
+  for (const idx of candidates) {
+    let score = 0;
+    let maxScore = 0;
+    if (context.prev !== undefined) {
+      score += similarity(lines[idx - 1] || "", context.prev);
+      maxScore += 1;
+    }
+    if (context.next !== undefined) {
+      score += similarity(lines[idx + 1] || "", context.next);
+      maxScore += 1;
+    }
+    const normalizedScore = maxScore > 0 ? score / maxScore : 0;
+    if (!best || normalizedScore > best.score) {
+      best = { index: idx, score: normalizedScore };
+    }
+  }
+  if (best && best.score > 0.5) {
+    const confidence = 0.7 + best.score * 0.2;
+    return { index: best.index, confidence };
+  }
+  return null;
+}
+function similarity(a, b) {
+  if (a === b)
+    return 1;
+  if (!a || !b)
+    return 0;
+  const normA = normalizeWhitespace(a);
+  const normB = normalizeWhitespace(b);
+  if (normA === normB)
+    return 0.95;
+  const tokensA = tokenize(normA);
+  const tokensB = tokenize(normB);
+  if (tokensA.length === 0 && tokensB.length === 0)
+    return 1;
+  if (tokensA.length === 0 || tokensB.length === 0)
+    return 0;
+  const setA = new Set(tokensA);
+  const setB = new Set(tokensB);
+  let intersection = 0;
+  for (const token of setA) {
+    if (setB.has(token))
+      intersection++;
+  }
+  const union = setA.size + setB.size - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+function normalizeWhitespace(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function tokenize(s) {
+  return s.split(/[^a-zA-Z0-9_]+/).filter((t) => t.length > 0).map((t) => t.toLowerCase());
+}
+function aggregateToRanges(attributions) {
+  if (attributions.length === 0)
+    return [];
+  const sorted = [...attributions].sort((a, b) => a.line - b.line);
+  const ranges = [];
+  let current = {
+    startLine: sorted[0].line,
+    endLine: sorted[0].line,
+    sessionId: sorted[0].sessionId
+  };
+  for (let i = 1;i < sorted.length; i++) {
+    const attr = sorted[i];
+    if (attr.line === current.endLine + 1 && attr.sessionId === current.sessionId) {
+      current.endLine = attr.line;
+    } else {
+      ranges.push(current);
+      current = {
+        startLine: attr.line,
+        endLine: attr.line,
+        sessionId: attr.sessionId
+      };
+    }
+  }
+  ranges.push(current);
+  return ranges;
+}
+function separateRanges(ranges) {
+  const aiRanges = [];
+  const humanRanges = [];
+  for (const range of ranges) {
+    if (range.sessionId) {
+      aiRanges.push({
+        startLine: range.startLine,
+        endLine: range.endLine,
+        sessionId: range.sessionId
+      });
+    } else {
+      humanRanges.push({
+        startLine: range.startLine,
+        endLine: range.endLine
+      });
+    }
+  }
+  return { aiRanges, humanRanges };
+}
+function formatRanges(ranges) {
+  return ranges.map((r) => r.startLine === r.endLine ? `${r.startLine}` : `${r.startLine}-${r.endLine}`).join(",");
+}
+function parseRanges(str) {
+  if (!str)
+    return [];
+  return str.split(",").map((part) => {
+    const [start, end] = part.split("-").map((n) => parseInt(n, 10));
+    return {
+      startLine: start,
+      endLine: end ?? start
+    };
+  });
+}
+function buildSessionMap(fileAttributions) {
+  const sessionMap = new Map;
+  for (const [filePath, attributions] of fileAttributions) {
+    for (const { line, sessionId } of attributions) {
+      if (!sessionId)
+        continue;
+      if (!sessionMap.has(sessionId)) {
+        sessionMap.set(sessionId, new Map);
+      }
+      const fileMap = sessionMap.get(sessionId);
+      if (!fileMap.has(filePath)) {
+        fileMap.set(filePath, []);
+      }
+      fileMap.get(filePath).push(line);
+    }
+  }
+  return sessionMap;
+}
+function buildHumanMap(fileAttributions) {
+  const humanMap = new Map;
+  for (const [filePath, attributions] of fileAttributions) {
+    const humanLines = [];
+    for (const { line, sessionId } of attributions) {
+      if (!sessionId) {
+        humanLines.push(line);
+      }
+    }
+    if (humanLines.length > 0) {
+      humanMap.set(filePath, humanLines);
+    }
+  }
+  return humanMap;
+}
+
+// src/lib/git/gitNotes.ts
+var NOTES_REF = "refs/notes/agentblame";
+function buildV3Note(attribution, sessions) {
+  const lines = [];
+  for (const [filePath, fileAttr] of Object.entries(attribution.files)) {
+    lines.push(filePath);
+    const sessionRanges = new Map;
+    for (const range of fileAttr.aiRanges) {
+      if (!sessionRanges.has(range.sessionId)) {
+        sessionRanges.set(range.sessionId, []);
+      }
+      sessionRanges.get(range.sessionId).push([range.startLine, range.endLine]);
+    }
+    for (const [sessionId, ranges] of sessionRanges) {
+      const rangeStr = formatRanges(ranges.map(([start, end]) => ({ startLine: start, endLine: end })));
+      lines.push(`  ${sessionId} ${rangeStr}`);
+    }
+  }
+  lines.push("---");
+  const metadata = {
+    v: 3,
+    ts: attribution.timestamp,
+    sessions,
+    h: {}
+  };
+  for (const [filePath, fileAttr] of Object.entries(attribution.files)) {
+    if (fileAttr.humanRanges.length > 0) {
+      metadata.h[filePath] = formatRanges(fileAttr.humanRanges);
+    }
+  }
+  lines.push(JSON.stringify(metadata));
+  return lines.join(`
+`);
+}
+function parseNote(content) {
+  if (!content.trim())
+    return null;
+  const dividerIndex = content.indexOf(`
+---
+`);
+  if (dividerIndex === -1) {
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  const attestation = content.substring(0, dividerIndex);
+  const metadataStr = content.substring(dividerIndex + 5).trim();
+  try {
+    const metadata = JSON.parse(metadataStr);
+    return parseV3Note(attestation, metadata);
+  } catch {
+    return null;
+  }
+}
+function parseV3Note(attestation, metadata) {
+  const attribution = {
+    version: 3,
+    timestamp: metadata.ts,
+    sessions: metadata.sessions,
+    files: {}
+  };
+  let currentFile = null;
+  for (const line of attestation.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    if (!line.startsWith("  ")) {
+      currentFile = line.trim();
+      attribution.files[currentFile] = {
+        aiRanges: [],
+        humanRanges: []
+      };
+    } else if (currentFile) {
+      const trimmed = line.trim();
+      const spaceIdx = trimmed.indexOf(" ");
+      if (spaceIdx > 0) {
+        const sessionId = trimmed.substring(0, spaceIdx);
+        const rangeStr = trimmed.substring(spaceIdx + 1);
+        const ranges = parseRanges(rangeStr);
+        for (const range of ranges) {
+          attribution.files[currentFile].aiRanges.push({
+            sessionId,
+            startLine: range.startLine,
+            endLine: range.endLine
+          });
+        }
+      }
+    }
+  }
+  for (const [filePath, rangeStr] of Object.entries(metadata.h)) {
+    if (!attribution.files[filePath]) {
+      attribution.files[filePath] = {
+        aiRanges: [],
+        humanRanges: []
+      };
+    }
+    attribution.files[filePath].humanRanges = parseRanges(rangeStr);
+  }
+  return attribution;
+}
+function isV3Note(note) {
+  return "version" in note && note.version === 3;
+}
+function convertV2ToV3(note) {
+  const v3 = {
+    version: 3,
+    timestamp: note.timestamp,
+    sessions: {},
+    files: {}
+  };
+  const sessionMap = new Map;
+  for (const attr of note.attributions) {
+    const key = `${attr.provider}:${attr.model || "unknown"}`;
+    if (!sessionMap.has(key)) {
+      const sessionId2 = `legacy-${sessionMap.size}`;
+      sessionMap.set(key, sessionId2);
+      v3.sessions[sessionId2] = {
+        a: providerToAgent(attr.provider),
+        m: attr.model,
+        p: null,
+        t: note.timestamp,
+        tools: []
+      };
+    }
+    const sessionId = sessionMap.get(key);
+    if (!v3.files[attr.path]) {
+      v3.files[attr.path] = {
+        aiRanges: [],
+        humanRanges: []
+      };
+    }
+    v3.files[attr.path].aiRanges.push({
+      sessionId,
+      startLine: attr.startLine,
+      endLine: attr.endLine
+    });
+  }
+  return v3;
+}
+function providerToAgent(provider) {
+  if (provider === "claudeCode")
+    return "claude";
+  if (provider === "cursor" || provider === "opencode")
+    return provider;
+  return "cursor";
+}
+async function attachNoteV3(repoRoot, sha, attribution, sessions) {
+  const noteContent = buildV3Note(attribution, sessions);
+  const result = await runGit(repoRoot, ["notes", `--ref=${NOTES_REF}`, "add", "-f", "-m", noteContent, sha], 1e4);
+  return result.exitCode === 0;
+}
+async function readNoteV3(repoRoot, sha) {
+  const result = await runGit(repoRoot, ["notes", `--ref=${NOTES_REF}`, "show", sha], 5000);
+  if (result.exitCode !== 0)
+    return null;
+  const parsed = parseNote(result.stdout.trim());
+  if (!parsed)
+    return null;
+  if (!isV3Note(parsed)) {
+    return convertV2ToV3(parsed);
+  }
+  return parsed;
+}
+async function fetchNotesQuiet(repoRoot, remote = "origin", verbose = false) {
+  if (verbose) {
+    console.log("Fetching attribution notes from remote...");
+  }
+  const result = await runGit(repoRoot, ["fetch", remote, `${NOTES_REF}:${NOTES_REF}`], 30000);
+  if (result.exitCode === 0) {
+    if (verbose) {
+      console.log(`Notes fetched successfully.
+`);
+    }
+    return true;
+  }
+  if (verbose) {
+    console.log(`No remote notes found (this is normal for new repos).
+`);
+  }
+  return false;
+}
+
+// src/blame.ts
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  orange: "\x1B[38;2;184;101;64m",
+  blue: "\x1B[34m",
+  gray: "\x1B[90m",
+  magenta: "\x1B[35m"
+};
+async function blame(filePath, options = {}) {
+  const absolutePath = path2.resolve(filePath);
+  if (!fs2.existsSync(absolutePath)) {
+    console.error(`Error: File not found: ${absolutePath}`);
+    process.exit(1);
+  }
+  const stat = fs2.statSync(absolutePath);
+  if (!stat.isFile()) {
+    console.error(`Error: Not a file: ${absolutePath}`);
+    process.exit(1);
+  }
+  const repoRoot = await getRepoRoot(path2.dirname(absolutePath));
+  if (!repoRoot) {
+    console.error("Error: Not in a git repository");
+    process.exit(1);
+  }
+  const relativePath = path2.relative(repoRoot, absolutePath);
+  if (relativePath.startsWith("..")) {
+    console.error("Error: File is outside the repository");
+    process.exit(1);
+  }
+  await fetchNotesQuiet(repoRoot);
+  let blameResult;
+  try {
+    blameResult = await getBlame(repoRoot, relativePath);
+  } catch (err) {
+    console.error(`Error: ${err}`);
+    process.exit(1);
+  }
+  const uniqueShas = [...new Set(blameResult.lines.map((l) => l.sha))];
+  const notesMap = new Map;
+  for (const sha of uniqueShas) {
+    const note = await readNoteV3(repoRoot, sha);
+    if (note) {
+      notesMap.set(sha, note);
+    }
+  }
+  const lineAttributions = blameResult.lines.map((line) => {
+    const note = notesMap.get(line.sha);
+    if (!note) {
+      return { line, sessionId: null, session: null };
+    }
+    const fileAttr = note.files[relativePath];
+    if (!fileAttr) {
+      const matchingPath = Object.keys(note.files).find((p) => p === relativePath || p.endsWith(relativePath) || relativePath.endsWith(p));
+      if (!matchingPath) {
+        return { line, sessionId: null, session: null };
+      }
+      const altFileAttr = note.files[matchingPath];
+      const aiRange2 = altFileAttr.aiRanges.find((r) => line.origLine >= r.startLine && line.origLine <= r.endLine);
+      if (aiRange2) {
+        return {
+          line,
+          sessionId: aiRange2.sessionId,
+          session: note.sessions[aiRange2.sessionId] || null
+        };
+      }
+      return { line, sessionId: null, session: null };
+    }
+    const aiRange = fileAttr.aiRanges.find((r) => line.origLine >= r.startLine && line.origLine <= r.endLine);
+    if (aiRange) {
+      return {
+        line,
+        sessionId: aiRange.sessionId,
+        session: note.sessions[aiRange.sessionId] || null
+      };
+    }
+    return { line, sessionId: null, session: null };
+  });
+  const uniqueSessions = new Map;
+  for (const { sessionId, session } of lineAttributions) {
+    if (sessionId && session && !uniqueSessions.has(sessionId)) {
+      uniqueSessions.set(sessionId, session);
+    }
+  }
+  if (options.json) {
+    outputJson(lineAttributions, relativePath, uniqueSessions);
+  } else if (options.summary) {
+    outputSummary(lineAttributions, relativePath, uniqueSessions);
+  } else {
+    outputFormatted(lineAttributions, relativePath, uniqueSessions, options.showPrompts);
+  }
+}
+function outputFormatted(lines, filePath, sessions, showPrompts = true) {
+  console.log("");
+  console.log(`  ${c.bold}${c.cyan}${filePath}${c.reset}`);
+  console.log(`  ${c.dim}${"\u2500".repeat(70)}${c.reset}`);
+  if (showPrompts && sessions.size > 0) {
+    console.log(`  ${c.bold}Sessions:${c.reset}`);
+    for (const [sessionId, session] of sessions) {
+      const agent = session.a === "cursor" ? "Cursor" : session.a === "opencode" ? "OpenCode" : "Claude";
+      const model = session.m || "";
+      const modelStr = model ? ` - ${model}` : "";
+      console.log(`  ${c.orange}${sessionId.slice(0, 8)}${c.reset} ${c.dim}[${agent}${modelStr}]${c.reset}`);
+      if (session.p) {
+        const prompt = session.p.length > 80 ? session.p.substring(0, 80) + "..." : session.p;
+        console.log(`    ${c.dim}"${prompt}"${c.reset}`);
+      }
+      if (session.tools.length > 0) {
+        console.log(`    ${c.dim}Tools: ${session.tools.join(", ")}${c.reset}`);
+      }
+    }
+    console.log(`  ${c.dim}${"\u2500".repeat(70)}${c.reset}`);
+  }
+  const maxLineNum = lines.length.toString().length;
+  for (const { line, sessionId, session } of lines) {
+    const sha = `${c.yellow}${line.sha.slice(0, 7)}${c.reset}`;
+    const author = `${c.blue}${line.author.slice(0, 12).padEnd(12)}${c.reset}`;
+    const date = `${c.dim}${formatDate(line.authorTime)}${c.reset}`;
+    const lineNum = `${c.dim}${line.lineNumber.toString().padStart(maxLineNum)}${c.reset}`;
+    const ATTR_WIDTH = 24;
+    let attrInfo = "";
+    let visibleLen = 0;
+    if (sessionId && session) {
+      const agent = session.a === "cursor" ? "Cursor" : session.a === "opencode" ? "OpenCode" : "Claude";
+      const label = `${sessionId.slice(0, 8)} ${agent}`;
+      visibleLen = label.length + 3;
+      attrInfo = `${c.orange}\u2728 ${sessionId.slice(0, 8)} ${c.dim}${agent}${c.reset}`;
+    }
+    const attrPadded = sessionId ? attrInfo + " ".repeat(Math.max(0, ATTR_WIDTH - visibleLen)) : " ".repeat(ATTR_WIDTH);
+    console.log(`  ${sha} ${author} ${date} ${attrPadded} ${c.dim}\u2502${c.reset} ${lineNum} ${c.dim}\u2502${c.reset} ${line.content}`);
+  }
+  const nonEmptyLines = filterNonEmptyLines(lines);
+  const aiGenerated = nonEmptyLines.filter((l) => l.sessionId !== null).length;
+  const human = nonEmptyLines.length - aiGenerated;
+  const aiPct = nonEmptyLines.length > 0 ? Math.round(aiGenerated / nonEmptyLines.length * 100) : 0;
+  const humanPct = 100 - aiPct;
+  const barWidth = 40;
+  const aiBarWidth = Math.round(aiPct / 100 * barWidth);
+  const humanBarWidth = barWidth - aiBarWidth;
+  const aiBar = `${c.orange}${"\u2588".repeat(aiBarWidth)}${c.reset}`;
+  const humanBar = `${c.dim}${"\u2591".repeat(humanBarWidth)}${c.reset}`;
+  console.log(`  ${c.dim}${"\u2500".repeat(70)}${c.reset}`);
+  console.log(`  ${aiBar}${humanBar}`);
+  console.log(`  ${c.orange}\u2728 AI: ${aiGenerated} (${aiPct}%)${c.reset}  ${c.dim}\u2502${c.reset}  ${c.green}\uD83D\uDC64 Human: ${human} (${humanPct}%)${c.reset}`);
+  console.log("");
+}
+function outputSummary(lines, filePath, sessions) {
+  const nonEmptyLines = filterNonEmptyLines(lines);
+  const aiGenerated = nonEmptyLines.filter((l) => l.sessionId !== null).length;
+  const human = nonEmptyLines.length - aiGenerated;
+  console.log(`
+${filePath}:`);
+  console.log(`  Total lines:   ${nonEmptyLines.length}`);
+  console.log(`  AI-generated:  ${aiGenerated} (${pct(aiGenerated, nonEmptyLines.length)})`);
+  console.log(`  Human:         ${human} (${pct(human, nonEmptyLines.length)})`);
+  console.log("");
+  const sessionCounts = new Map;
+  for (const { sessionId } of nonEmptyLines) {
+    if (sessionId) {
+      sessionCounts.set(sessionId, (sessionCounts.get(sessionId) || 0) + 1);
+    }
+  }
+  if (sessionCounts.size > 0) {
+    console.log("  By session:");
+    for (const [sessionId, count] of sessionCounts) {
+      const session = sessions.get(sessionId);
+      const agent = session?.a || "unknown";
+      const model = session?.m || "";
+      console.log(`    ${sessionId.slice(0, 8)} [${agent}${model ? ` - ${model}` : ""}]: ${count} lines`);
+    }
+    console.log("");
+  }
+  const agentCounts = new Map;
+  for (const { session } of nonEmptyLines) {
+    if (session) {
+      const agent = session.a;
+      agentCounts.set(agent, (agentCounts.get(agent) || 0) + 1);
+    }
+  }
+  if (agentCounts.size > 0) {
+    console.log("  By agent:");
+    for (const [agent, count] of agentCounts) {
+      console.log(`    ${agent}: ${count} lines`);
+    }
+    console.log("");
+  }
+  if (sessions.size > 0) {
+    console.log("  Prompts:");
+    for (const [sessionId, session] of sessions) {
+      if (session.p) {
+        const truncated = session.p.length > 60 ? session.p.substring(0, 60) + "..." : session.p;
+        console.log(`    ${sessionId.slice(0, 8)}: "${truncated}"`);
+      }
+    }
+    console.log("");
+  }
+}
+function outputJson(lines, filePath, sessions) {
+  const nonEmptyLines = filterNonEmptyLines(lines);
+  const output = {
+    file: filePath,
+    sessions: Object.fromEntries(Array.from(sessions.entries()).map(([id, session]) => [
+      id,
+      {
+        agent: session.a,
+        model: session.m,
+        prompt: session.p,
+        timestamp: session.t,
+        tools: session.tools
+      }
+    ])),
+    lines: lines.map(({ line, sessionId, session }) => ({
+      lineNumber: line.lineNumber,
+      sha: line.sha,
+      author: line.author,
+      date: line.authorTime.toISOString(),
+      content: line.content,
+      attribution: sessionId ? {
+        sessionId,
+        agent: session?.a || null,
+        model: session?.m || null,
+        prompt: session?.p || null
+      } : null
+    })),
+    summary: {
+      total: nonEmptyLines.length,
+      aiGenerated: nonEmptyLines.filter((l) => l.sessionId !== null).length,
+      human: nonEmptyLines.filter((l) => l.sessionId === null).length
+    }
+  };
+  console.log(JSON.stringify(output, null, 2));
+}
+function formatDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+function pct(n, total) {
+  if (total === 0)
+    return "0%";
+  return `${Math.round(n / total * 100)}%`;
+}
+function isEmptyLine(line) {
+  return line.line.content.trim() === "";
+}
+function filterNonEmptyLines(lines) {
+  return lines.filter((l) => !isEmptyLine(l));
+}
+
+// src/sync.ts
+import { execSync, spawnSync } from "child_process";
+// src/lib/database.ts
+import { Database } from "bun:sqlite";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { createHash } from "crypto";
+var SCHEMA_V3 = `
+-- Sessions: One per AI conversation
+CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,              -- SHA256(agent:conversation_id)[0:16]
+    agent TEXT NOT NULL,              -- 'cursor' | 'claude' | 'opencode'
+    model TEXT,
+    conversation_id TEXT,             -- Original ID from agent
+    created_at TEXT NOT NULL,
+    first_commit_sha TEXT,            -- First commit using this session
+    first_commit_at TEXT
+);
+
+-- Prompts: User messages that triggered AI actions
+CREATE TABLE IF NOT EXISTS prompts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    content TEXT NOT NULL,            -- The actual prompt text
+    timestamp TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
+);
+
+-- Tool Calls: What the AI did
+CREATE TABLE IF NOT EXISTS tool_calls (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    tool_name TEXT NOT NULL,          -- 'Edit', 'Write', 'MultiEdit'
+    tool_input TEXT,                  -- JSON of tool arguments
+    file_path TEXT,
+    timestamp TEXT NOT NULL,
+    before_blob TEXT,                 -- Git blob SHA of file before
+    after_blob TEXT,                  -- Git blob SHA of file after
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent, conversation_id);
+CREATE INDEX IF NOT EXISTS idx_prompts_session ON prompts(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_file ON tool_calls(file_path);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_timestamp ON tool_calls(timestamp);
+`;
+var dbInstance = null;
+var currentDbPath = null;
+function setDatabasePath(dbPath) {
+  if (currentDbPath !== dbPath) {
+    if (dbInstance) {
+      dbInstance.close();
+      dbInstance = null;
+    }
+    currentDbPath = dbPath;
+  }
+}
+function getDbPath() {
+  if (!currentDbPath) {
+    throw new Error("Database path not set. Call setDatabasePath() or setAgentBlameDir() first.");
+  }
+  return currentDbPath;
+}
+function getDatabase() {
+  if (dbInstance) {
+    return dbInstance;
+  }
+  const dbPath = getDbPath();
+  const dbDir = path3.dirname(dbPath);
+  if (!fs3.existsSync(dbDir)) {
+    fs3.mkdirSync(dbDir, { recursive: true });
+  }
+  dbInstance = new Database(dbPath);
+  dbInstance.exec("PRAGMA foreign_keys = ON");
+  dbInstance.exec("PRAGMA journal_mode = WAL");
+  dbInstance.exec("PRAGMA busy_timeout = 5000");
+  dbInstance.exec(SCHEMA_V3);
+  return dbInstance;
+}
+function initDatabase() {
+  const db = getDatabase();
+  db.exec("SELECT 1");
+}
+function resetDatabase() {
+  const db = getDatabase();
+  db.exec("DROP TABLE IF EXISTS lines");
+  db.exec("DROP TABLE IF EXISTS edits");
+  db.exec("DROP TABLE IF EXISTS tool_calls");
+  db.exec("DROP TABLE IF EXISTS prompts");
+  db.exec("DROP TABLE IF EXISTS sessions");
+  db.exec(SCHEMA_V3);
+}
+function upsertSession(params) {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    INSERT INTO sessions (id, agent, model, conversation_id, created_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      model = COALESCE(excluded.model, sessions.model)
+  `);
+  stmt.run(params.id, params.agent, params.model ?? null, params.conversationId ?? null, new Date().toISOString());
+}
+function getSession(sessionId) {
+  const db = getDatabase();
+  const stmt = db.prepare("SELECT * FROM sessions WHERE id = ?");
+  const row = stmt.get(sessionId);
+  if (!row)
+    return null;
+  return {
+    id: row.id,
+    agent: row.agent,
+    model: row.model,
+    conversationId: row.conversation_id,
+    createdAt: row.created_at,
+    firstCommitSha: row.first_commit_sha,
+    firstCommitAt: row.first_commit_at
+  };
+}
+function updateSessionFirstCommit(sessionId, commitSha) {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    UPDATE sessions
+    SET first_commit_sha = COALESCE(first_commit_sha, ?),
+        first_commit_at = COALESCE(first_commit_at, ?)
+    WHERE id = ?
+  `);
+  stmt.run(commitSha, new Date().toISOString(), sessionId);
+}
+function insertPrompt(params) {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    INSERT INTO prompts (session_id, content, timestamp)
+    VALUES (?, ?, ?)
+  `);
+  const result = stmt.run(params.sessionId, params.content, params.timestamp ?? new Date().toISOString());
+  return Number(result.lastInsertRowid);
+}
+function getLatestPromptForSession(sessionId) {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    SELECT * FROM prompts
+    WHERE session_id = ?
+    ORDER BY timestamp DESC
+    LIMIT 1
+  `);
+  const row = stmt.get(sessionId);
+  return row ? rowToPrompt(row) : null;
+}
+function promptExists(sessionId, content) {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    SELECT 1 FROM prompts
+    WHERE session_id = ? AND content = ?
+    LIMIT 1
+  `);
+  return stmt.get(sessionId, content) !== undefined;
+}
+function insertToolCall(params) {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    INSERT INTO tool_calls (
+      session_id, tool_name, tool_input, file_path, timestamp, before_blob, after_blob
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const result = stmt.run(params.sessionId, params.toolName, params.toolInput ?? null, params.filePath ?? null, params.timestamp ?? new Date().toISOString(), params.beforeBlob ?? null, params.afterBlob ?? null);
+  return Number(result.lastInsertRowid);
+}
+function getToolNamesForSession(sessionId) {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    SELECT DISTINCT tool_name FROM tool_calls
+    WHERE session_id = ?
+    ORDER BY tool_name
+  `);
+  const rows = stmt.all(sessionId);
+  return rows.map((r) => r.tool_name);
+}
+function cleanupOldEntries(maxAgeDays = 30) {
+  const db = getDatabase();
+  const beforeCount = db.prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+  db.prepare(`
+    DELETE FROM sessions
+    WHERE first_commit_sha IS NULL
+    AND datetime(created_at) < datetime('now', '-' || ? || ' days')
+  `).run(maxAgeDays);
+  const afterCount = db.prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+  return {
+    removed: beforeCount - afterCount,
+    kept: afterCount
+  };
+}
+function getRecentSessions(limit = 5) {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    SELECT * FROM sessions
+    ORDER BY created_at DESC
+    LIMIT ?
+  `);
+  const rows = stmt.all(limit);
+  return rows.map(rowToSession);
+}
+function getStats() {
+  const db = getDatabase();
+  const sessions = db.prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+  const prompts = db.prepare("SELECT COUNT(*) as count FROM prompts").get().count;
+  const toolCalls = db.prepare("SELECT COUNT(*) as count FROM tool_calls").get().count;
+  return { sessions, prompts, toolCalls };
+}
+function rowToSession(row) {
+  return {
+    id: row.id,
+    agent: row.agent,
+    model: row.model,
+    conversationId: row.conversation_id,
+    createdAt: row.created_at,
+    firstCommitSha: row.first_commit_sha,
+    firstCommitAt: row.first_commit_at
+  };
+}
+function rowToPrompt(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    content: row.content,
+    timestamp: row.timestamp
+  };
+}
+function generateSessionId(agent, conversationId) {
+  const hash = createHash("sha256");
+  hash.update(`${agent}:${conversationId}`);
+  return hash.digest("hex").substring(0, 16);
+}
+// src/lib/watcher.ts
+import { watch } from "fs";
+import * as fs4 from "fs";
+import * as path4 from "path";
+class FileWatcher {
+  watcher = null;
+  repoRoot;
+  aiEditInProgress = new Set;
+  debounceTimers = new Map;
+  debounceMs;
+  lastCapturedBlobs = new Map;
+  constructor(repoRoot, options) {
+    this.repoRoot = repoRoot;
+    this.debounceMs = options?.debounceMs ?? 500;
+  }
+  start() {
+    if (this.watcher) {
+      return;
+    }
+    try {
+      this.watcher = watch(this.repoRoot, { recursive: true }, (event, filename) => {
+        if (!filename)
+          return;
+        if (this.shouldIgnore(filename))
+          return;
+        this.debounce(filename, async () => {
+          await this.handleFileChange(filename);
+        });
+      });
+      this.watcher.on("error", (err) => {
+        console.error("[agentblame] Watcher error:", err.message);
+      });
+    } catch (err) {
+      console.error("[agentblame] Failed to start watcher:", err);
+    }
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  markAIEditStart(filePath) {
+    const normalized = this.normalizePath(filePath);
+    this.aiEditInProgress.add(normalized);
+  }
+  markAIEditEnd(filePath) {
+    const normalized = this.normalizePath(filePath);
+    this.aiEditInProgress.delete(normalized);
+  }
+  isAIEditInProgress(filePath) {
+    const normalized = this.normalizePath(filePath);
+    return this.aiEditInProgress.has(normalized);
+  }
+  async handleFileChange(relativePath) {
+    const absolutePath = path4.join(this.repoRoot, relativePath);
+    const normalized = this.normalizePath(relativePath);
+    if (this.aiEditInProgress.has(normalized)) {
+      return;
+    }
+    if (!fs4.existsSync(absolutePath)) {
+      return;
+    }
+    try {
+      const stat = fs4.statSync(absolutePath);
+      if (stat.isDirectory())
+        return;
+    } catch {
+      return;
+    }
+    const content = readFileContent(absolutePath);
+    if (content === null)
+      return;
+    const baseSha = await getGitHead(this.repoRoot);
+    if (!baseSha)
+      return;
+    try {
+      const blobSha = await captureFileSnapshot(this.repoRoot, baseSha, relativePath, content, null, "human_edit");
+      this.lastCapturedBlobs.set(normalized, blobSha);
+    } catch (err) {
+      if (process.env.AGENTBLAME_DEBUG) {
+        console.error("[agentblame] Failed to capture human edit:", err);
+      }
+    }
+  }
+  shouldIgnore(relativePath) {
+    if (relativePath.startsWith(".git"))
+      return true;
+    if (relativePath.includes("/.git/"))
+      return true;
+    if (relativePath.includes("node_modules"))
+      return true;
+    if (relativePath.includes("/dist/"))
+      return true;
+    if (relativePath.includes("/build/"))
+      return true;
+    if (relativePath.includes("/.next/"))
+      return true;
+    if (relativePath.includes(".agentblame"))
+      return true;
+    if (relativePath.endsWith(".lock"))
+      return true;
+    if (relativePath.endsWith("-lock.json"))
+      return true;
+    if (relativePath.endsWith(".log"))
+      return true;
+    const binaryExtensions = [
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".ico",
+      ".webp",
+      ".mp3",
+      ".mp4",
+      ".wav",
+      ".avi",
+      ".mov",
+      ".pdf",
+      ".zip",
+      ".tar",
+      ".gz",
+      ".rar",
+      ".7z",
+      ".exe",
+      ".dll",
+      ".so",
+      ".dylib",
+      ".wasm",
+      ".ttf",
+      ".woff",
+      ".woff2",
+      ".eot"
+    ];
+    const ext = path4.extname(relativePath).toLowerCase();
+    if (binaryExtensions.includes(ext))
+      return true;
+    return false;
+  }
+  debounce(key, fn) {
+    const existing = this.debounceTimers.get(key);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timer = setTimeout(async () => {
+      this.debounceTimers.delete(key);
+      try {
+        await fn();
+      } catch (err) {
+        if (process.env.AGENTBLAME_DEBUG) {
+          console.error("[agentblame] Debounced function error:", err);
+        }
+      }
+    }, this.debounceMs);
+    this.debounceTimers.set(key, timer);
+  }
+  normalizePath(filePath) {
+    return filePath.replace(/^\.?\//, "").replace(/\\/g, "/");
+  }
+}
+var globalWatcher = null;
+function markAIEditStart(filePath) {
+  if (globalWatcher) {
+    globalWatcher.markAIEditStart(filePath);
+  }
+}
+function markAIEditEnd(filePath) {
+  if (globalWatcher) {
+    globalWatcher.markAIEditEnd(filePath);
+  }
+}
+// src/lib/analytics.ts
+import { spawn as spawn3 } from "child_process";
+var ANALYTICS_REF = "refs/notes/agentblame-analytics";
+async function getAnalyticsAnchor(repoRoot) {
+  return getRootCommit(repoRoot);
+}
+async function readAnalyticsNote(repoRoot) {
+  const anchor = await getAnalyticsAnchor(repoRoot);
+  if (!anchor)
+    return null;
+  return new Promise((resolve2) => {
+    const proc = spawn3("git", ["notes", "--ref", ANALYTICS_REF, "show", anchor], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0 && stdout.trim()) {
+        try {
+          const note = JSON.parse(stdout);
+          resolve2(note);
+        } catch {
+          resolve2(null);
+        }
+      } else {
+        resolve2(null);
+      }
+    });
+    proc.on("error", () => {
+      resolve2(null);
+    });
+  });
+}
+async function writeAnalyticsNote(repoRoot, analytics) {
+  const anchor = await getAnalyticsAnchor(repoRoot);
+  if (!anchor)
+    return false;
+  const content = JSON.stringify(analytics, null, 2);
+  return new Promise((resolve2) => {
+    const proc = spawn3("git", ["notes", "--ref", ANALYTICS_REF, "add", "-f", "-m", content, anchor], {
+      cwd: repoRoot,
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    proc.on("close", (code) => {
+      resolve2(code === 0);
+    });
+    proc.on("error", () => {
+      resolve2(false);
+    });
+  });
+}
+function computeCommitStats(sessions, fileAttributions) {
+  const stats = {
+    aiLines: 0,
+    humanLines: 0,
+    byAgent: {},
+    byModel: {},
+    sessions: []
+  };
+  const sessionIds = new Set;
+  for (const file of Object.values(fileAttributions)) {
+    for (const range of file.aiRanges) {
+      const lineCount = range.endLine - range.startLine + 1;
+      stats.aiLines += lineCount;
+      const session = sessions[range.sessionId];
+      if (session) {
+        sessionIds.add(range.sessionId);
+        const agent = session.a;
+        stats.byAgent[agent] = (stats.byAgent[agent] || 0) + lineCount;
+        if (session.m) {
+          stats.byModel[session.m] = (stats.byModel[session.m] || 0) + lineCount;
+        }
+      }
+    }
+    for (const range of file.humanRanges) {
+      stats.humanLines += range.endLine - range.startLine + 1;
+    }
+  }
+  stats.sessions = Array.from(sessionIds);
+  return stats;
+}
+function mergeAnalytics(existing, commitStats, commitAuthor) {
+  const base = existing || {
+    v: 1,
+    updated: new Date().toISOString(),
+    summary: {
+      totalLines: 0,
+      aiLines: 0,
+      humanLines: 0,
+      byAgent: {},
+      byModel: {}
+    },
+    contributors: {},
+    recentPRs: []
+  };
+  base.summary.aiLines += commitStats.aiLines;
+  base.summary.humanLines += commitStats.humanLines;
+  base.summary.totalLines = base.summary.aiLines + base.summary.humanLines;
+  for (const [agent, count] of Object.entries(commitStats.byAgent)) {
+    const key = agent;
+    base.summary.byAgent[key] = (base.summary.byAgent[key] || 0) + count;
+  }
+  for (const [model, count] of Object.entries(commitStats.byModel)) {
+    base.summary.byModel[model] = (base.summary.byModel[model] || 0) + count;
+  }
+  if (commitAuthor) {
+    if (!base.contributors[commitAuthor]) {
+      base.contributors[commitAuthor] = {
+        commits: 0,
+        aiLines: 0,
+        humanLines: 0,
+        topModels: []
+      };
+    }
+    const contributor = base.contributors[commitAuthor];
+    contributor.commits += 1;
+    contributor.aiLines += commitStats.aiLines;
+    contributor.humanLines += commitStats.humanLines;
+    const modelCounts = new Map;
+    for (const model of contributor.topModels) {
+      modelCounts.set(model, (modelCounts.get(model) || 0) + 1);
+    }
+    for (const [model, count] of Object.entries(commitStats.byModel)) {
+      modelCounts.set(model, (modelCounts.get(model) || 0) + count);
+    }
+    contributor.topModels = Array.from(modelCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([model]) => model);
+  }
+  base.updated = new Date().toISOString();
+  return base;
+}
+async function updateAnalytics(repoRoot, commitStats, commitAuthor) {
+  try {
+    const existing = await readAnalyticsNote(repoRoot);
+    const updated = mergeAnalytics(existing, commitStats, commitAuthor);
+    return await writeAnalyticsNote(repoRoot, updated);
+  } catch (err) {
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error("[agentblame] Failed to update analytics:", err);
+    }
+    return false;
+  }
+}
+async function initAnalytics(repoRoot) {
+  const existing = await readAnalyticsNote(repoRoot);
+  if (!existing) {
+    const initial = {
+      v: 1,
+      updated: new Date().toISOString(),
+      summary: {
+        totalLines: 0,
+        aiLines: 0,
+        humanLines: 0,
+        byAgent: {},
+        byModel: {}
+      },
+      contributors: {},
+      recentPRs: []
+    };
+    return await writeAnalyticsNote(repoRoot, initial);
+  }
+  return true;
+}
+// src/lib/hooks.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function getCursorHooksPath(repoRoot) {
+  return path5.join(repoRoot, ".cursor", "hooks.json");
+}
+function getClaudeSettingsPath(repoRoot) {
+  return path5.join(repoRoot, ".claude", "settings.json");
+}
+function getOpenCodePluginDir(repoRoot) {
+  return path5.join(repoRoot, ".opencode", "plugin");
+}
+function getOpenCodePluginPath(repoRoot) {
+  return path5.join(getOpenCodePluginDir(repoRoot), "agentblame.ts");
+}
+function getHookCommand(provider, event) {
+  const eventArg = event ? ` --event ${event}` : "";
+  return `agentblame capture --provider ${provider}${eventArg}`;
+}
+var OPENCODE_PLUGIN_TEMPLATE = `import type { Plugin } from "@opencode-ai/plugin"
+import { execSync } from "child_process"
+
+export default (async (ctx: any) => {
+  return {
+    "tool.execute.after": async (input: any, output: any) => {
+      // Only capture edit and write tools
+      if (input?.tool !== "edit" && input?.tool !== "write") {
+        return
+      }
+
+      try {
+        // Get model info from config
+        let model: string | null = null
+        if (ctx?.client?.config?.providers) {
+          try {
+            const configResult = await ctx.client.config.providers()
+            const config = configResult?.data || configResult
+            const activeProvider = config?.connected?.[0]
+            if (activeProvider && config?.default?.[activeProvider]) {
+              const modelId = config.default[activeProvider]
+              // Try to get display name from provider models
+              const provider = config?.providers?.find((p: any) => p.id === activeProvider)
+              const modelInfo = provider?.models?.[modelId]
+              model = modelInfo?.name || modelId
+            }
+          } catch {
+            // Ignore config errors
+          }
+        }
+
+        // Build payload based on tool type
+        const payload: any = {
+          tool: input.tool,
+          sessionID: input.sessionID,
+          callID: input.callID,
+        }
+
+        if (input.tool === "edit") {
+          // Edit tool: has before/after content in metadata
+          payload.filePath = output?.metadata?.filediff?.file || output?.args?.filePath
+          payload.oldString = output?.args?.oldString
+          payload.newString = output?.args?.newString
+          payload.before = output?.metadata?.filediff?.before
+          payload.after = output?.metadata?.filediff?.after
+          payload.diff = output?.metadata?.diff
+        } else if (input.tool === "write") {
+          // Write tool: has content in args
+          payload.filePath = output?.args?.filePath || output?.metadata?.filepath
+          payload.content = output?.args?.content
+        }
+
+        if (model) {
+          payload.model = model
+        }
+
+        // Call agentblame capture with the payload
+        execSync("agentblame capture --provider opencode", {
+          input: JSON.stringify(payload),
+          cwd: ctx?.directory || process.cwd(),
+          stdio: ["pipe", "inherit", "inherit"],
+          timeout: 5000,
+        })
+      } catch {
+        // Silent failure - don't interrupt OpenCode
+      }
+    },
+  }
+}) satisfies Plugin
+`;
+async function installCursorHooks(repoRoot) {
+  if (process.platform === "win32") {
+    console.error("Windows is not supported yet");
+    return false;
+  }
+  const hooksPath = getCursorHooksPath(repoRoot);
+  try {
+    await fs5.promises.mkdir(path5.dirname(hooksPath), {
+      recursive: true
+    });
+    let config = {};
+    try {
+      const existing = await fs5.promises.readFile(hooksPath, "utf8");
+      config = JSON.parse(existing || "{}");
+    } catch {}
+    config.version = config.version ?? 1;
+    config.hooks = config.hooks ?? {};
+    const fileEditCommand = getHookCommand("cursor", "afterFileEdit");
+    config.hooks.afterFileEdit = config.hooks.afterFileEdit ?? [];
+    if (!Array.isArray(config.hooks.afterFileEdit)) {
+      config.hooks.afterFileEdit = [];
+    }
+    config.hooks.afterFileEdit = config.hooks.afterFileEdit.filter((h) => !h?.command?.includes("agentblame") && !h?.command?.includes("capture.ts"));
+    config.hooks.afterFileEdit.push({ command: fileEditCommand });
+    if (config.hooks.afterTabFileEdit) {
+      config.hooks.afterTabFileEdit = config.hooks.afterTabFileEdit.filter((h) => !h?.command?.includes("agentblame") && !h?.command?.includes("capture.ts"));
+      if (config.hooks.afterTabFileEdit.length === 0) {
+        delete config.hooks.afterTabFileEdit;
+      }
+    }
+    await fs5.promises.writeFile(hooksPath, JSON.stringify(config, null, 2), "utf8");
+    return true;
+  } catch (err) {
+    console.error("Failed to install Cursor hooks:", err);
+    return false;
+  }
+}
+async function installClaudeHooks(repoRoot) {
+  if (process.platform === "win32") {
+    console.error("Windows is not supported yet");
+    return false;
+  }
+  const settingsPath = getClaudeSettingsPath(repoRoot);
+  try {
+    await fs5.promises.mkdir(path5.dirname(settingsPath), { recursive: true });
+    let config = {};
+    try {
+      const existing = await fs5.promises.readFile(settingsPath, "utf8");
+      config = JSON.parse(existing || "{}");
+    } catch {}
+    config.hooks = config.hooks ?? {};
+    const hookCommand = getHookCommand("claude");
+    config.hooks.PostToolUse = config.hooks.PostToolUse ?? [];
+    if (!Array.isArray(config.hooks.PostToolUse)) {
+      config.hooks.PostToolUse = [];
+    }
+    config.hooks.PostToolUse = config.hooks.PostToolUse.filter((h) => !h?.hooks?.some((hh) => hh?.command?.includes("agentblame") || hh?.command?.includes("capture.ts")));
+    config.hooks.PostToolUse.push({
+      matcher: "Edit|Write|MultiEdit",
+      hooks: [{ type: "command", command: hookCommand, async: true }]
+    });
+    await fs5.promises.writeFile(settingsPath, JSON.stringify(config, null, 2), "utf8");
+    return true;
+  } catch (err) {
+    console.error("Failed to install Claude hooks:", err);
+    return false;
+  }
+}
+async function installOpenCodeHooks(repoRoot) {
+  if (process.platform === "win32") {
+    console.error("Windows is not supported yet");
+    return false;
+  }
+  const pluginDir = getOpenCodePluginDir(repoRoot);
+  const pluginPath = getOpenCodePluginPath(repoRoot);
+  try {
+    await fs5.promises.mkdir(pluginDir, { recursive: true });
+    await fs5.promises.writeFile(pluginPath, OPENCODE_PLUGIN_TEMPLATE, "utf8");
+    return true;
+  } catch (err) {
+    console.error("Failed to install OpenCode hooks:", err);
+    return false;
+  }
+}
+async function uninstallOpenCodeHooks(repoRoot) {
+  try {
+    const pluginPath = getOpenCodePluginPath(repoRoot);
+    if (fs5.existsSync(pluginPath)) {
+      await fs5.promises.unlink(pluginPath);
+    }
+    return true;
+  } catch (err) {
+    console.error("Failed to uninstall OpenCode hooks:", err);
+    return false;
+  }
+}
+async function installGitHook(repoRoot) {
+  const hooksDir = path5.join(repoRoot, ".git", "hooks");
+  const hookPath = path5.join(hooksDir, "post-commit");
+  const hookContent = `#!/bin/sh
+# Agent Blame - Auto-process commits for AI attribution
+agentblame process HEAD 2>/dev/null || true
+
+# Push notes to remote (silently fails if no notes or no remote)
+git push origin refs/notes/agentblame:refs/notes/agentblame 2>/dev/null || true
+`;
+  try {
+    await fs5.promises.mkdir(hooksDir, { recursive: true });
+    let existingContent = "";
+    try {
+      existingContent = await fs5.promises.readFile(hookPath, "utf8");
+    } catch {}
+    if (existingContent.includes("agentblame") || existingContent.includes("Agent Blame")) {
+      existingContent = removeAgentBlameSection(existingContent);
+    }
+    if (existingContent.trim()) {
+      const newContent = existingContent.trimEnd() + `
+
+` + hookContent.split(`
+`).slice(1).join(`
+`);
+      await fs5.promises.writeFile(hookPath, newContent, { mode: 493 });
+    } else {
+      await fs5.promises.writeFile(hookPath, hookContent, { mode: 493 });
+    }
+    return true;
+  } catch (err) {
+    console.error("Failed to install git hook:", err);
+    return false;
+  }
+}
+function removeAgentBlameSection(content) {
+  const lines = content.split(`
+`);
+  const result = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const nextLine = lines[i + 1] || "";
+    if (line.includes("agentblame") || line.includes("Agent Blame")) {
+      continue;
+    }
+    if (line.includes("Push notes to remote") && nextLine.includes("refs/notes/agentblame")) {
+      continue;
+    }
+    if (line.trim() === "" && result.length > 0 && result[result.length - 1].trim() === "") {
+      continue;
+    }
+    result.push(line);
+  }
+  return result.join(`
+`);
+}
+async function uninstallGitHook(repoRoot) {
+  const hookPath = path5.join(repoRoot, ".git", "hooks", "post-commit");
+  try {
+    if (!fs5.existsSync(hookPath)) {
+      return true;
+    }
+    const content = await fs5.promises.readFile(hookPath, "utf8");
+    if (!content.includes("agentblame") && !content.includes("Agent Blame")) {
+      return true;
+    }
+    const newContent = removeAgentBlameSection(content);
+    const meaningfulLines = newContent.split(`
+`).filter((l) => l.trim() && !l.startsWith("#!"));
+    if (meaningfulLines.length === 0) {
+      await fs5.promises.unlink(hookPath);
+    } else {
+      await fs5.promises.writeFile(hookPath, newContent, { mode: 493 });
+    }
+    return true;
+  } catch (err) {
+    console.error("Failed to uninstall git hook:", err);
+    return false;
+  }
+}
+async function uninstallCursorHooks(repoRoot) {
+  try {
+    const hooksPath = getCursorHooksPath(repoRoot);
+    if (fs5.existsSync(hooksPath)) {
+      const config = JSON.parse(await fs5.promises.readFile(hooksPath, "utf8"));
+      if (config.hooks?.afterFileEdit) {
+        config.hooks.afterFileEdit = config.hooks.afterFileEdit.filter((h) => !h?.command?.includes("agentblame") && !h?.command?.includes("capture.ts"));
+      }
+      await fs5.promises.writeFile(hooksPath, JSON.stringify(config, null, 2), "utf8");
+    }
+    return true;
+  } catch (err) {
+    console.error("Failed to uninstall Cursor hooks:", err);
+    return false;
+  }
+}
+async function uninstallClaudeHooks(repoRoot) {
+  try {
+    const settingsPath = getClaudeSettingsPath(repoRoot);
+    if (fs5.existsSync(settingsPath)) {
+      const config = JSON.parse(await fs5.promises.readFile(settingsPath, "utf8"));
+      if (config.hooks?.PostToolUse) {
+        config.hooks.PostToolUse = config.hooks.PostToolUse.filter((h) => !h?.hooks?.some((hh) => hh?.command?.includes("agentblame") || hh?.command?.includes("capture.ts")));
+      }
+      await fs5.promises.writeFile(settingsPath, JSON.stringify(config, null, 2), "utf8");
+    }
+    return true;
+  } catch (err) {
+    console.error("Failed to uninstall Claude hooks:", err);
+    return false;
+  }
+}
+var GITHUB_WORKFLOW_CONTENT = `name: Agent Blame
+
+on:
+  pull_request:
+    types: [closed]
+
+jobs:
+  post-merge:
+    # Only run if the PR was merged (not just closed)
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write  # Needed to push notes
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Full history needed for notes and blame
+          ref: \${{ github.event.pull_request.base.ref }}  # Checkout target branch (e.g., main)
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+
+      - name: Configure git identity
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Install agentblame
+        run: npm install -g @mesadev/agentblame
+
+      - name: Fetch notes, tags, and PR head
+        run: |
+          git fetch origin refs/notes/agentblame:refs/notes/agentblame 2>/dev/null || echo "No existing attribution notes"
+          git fetch origin refs/notes/agentblame-analytics:refs/notes/agentblame-analytics 2>/dev/null || echo "No existing analytics notes"
+          git fetch origin --tags 2>/dev/null || echo "No tags to fetch"
+          git fetch origin refs/pull/\${{ github.event.pull_request.number }}/head:refs/pull/\${{ github.event.pull_request.number }}/head 2>/dev/null || echo "Could not fetch PR head"
+
+      - name: Process merge (transfer notes + update analytics)
+        run: bun $(npm root -g)/@mesadev/agentblame/dist/post-merge.js
+        env:
+          PR_NUMBER: \${{ github.event.pull_request.number }}
+          PR_TITLE: \${{ github.event.pull_request.title }}
+          PR_AUTHOR: \${{ github.event.pull_request.user.login }}
+          BASE_REF: \${{ github.event.pull_request.base.ref }}
+          BASE_SHA: \${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: \${{ github.event.pull_request.head.sha }}
+          MERGE_SHA: \${{ github.event.pull_request.merge_commit_sha }}
+
+      - name: Push notes and tags
+        run: |
+          # Push attribution notes
+          git push origin refs/notes/agentblame 2>/dev/null || echo "No attribution notes to push"
+          # Push analytics notes
+          git push origin refs/notes/agentblame-analytics 2>/dev/null || echo "No analytics notes to push"
+          # Push analytics anchor tag
+          git push origin agentblame-analytics-anchor 2>/dev/null || echo "No analytics tag to push"
+`;
+async function installGitHubAction(repoRoot) {
+  const workflowDir = path5.join(repoRoot, ".github", "workflows");
+  const workflowPath = path5.join(workflowDir, "agentblame.yml");
+  try {
+    await fs5.promises.mkdir(workflowDir, { recursive: true });
+    await fs5.promises.writeFile(workflowPath, GITHUB_WORKFLOW_CONTENT, "utf8");
+    return true;
+  } catch (err) {
+    console.error("Failed to install GitHub Action:", err);
+    return false;
+  }
+}
+async function uninstallGitHubAction(repoRoot) {
+  const workflowPath = path5.join(repoRoot, ".github", "workflows", "agentblame.yml");
+  try {
+    if (fs5.existsSync(workflowPath)) {
+      await fs5.promises.unlink(workflowPath);
+    }
+    return true;
+  } catch (err) {
+    console.error("Failed to uninstall GitHub Action:", err);
+    return false;
+  }
+}
+// src/lib/git/gitDiff.ts
+async function getCommitDiff(repoRoot, sha) {
+  const nameStatus = await runGit(repoRoot, [
+    "diff-tree",
+    "--no-commit-id",
+    "--name-status",
+    "-r",
+    sha
+  ]);
+  const files = [];
+  if (nameStatus.exitCode === 0) {
+    for (const line of nameStatus.stdout.split(`
+`)) {
+      if (!line.trim())
+        continue;
+      const [status, ...pathParts] = line.split("\t");
+      const path6 = pathParts.join("\t");
+      if (!path6)
+        continue;
+      let fileStatus = "modified";
+      if (status === "A")
+        fileStatus = "added";
+      else if (status === "D")
+        fileStatus = "deleted";
+      files.push({ path: path6, status: fileStatus });
+    }
+  }
+  const result = await runGit(repoRoot, [
+    "diff",
+    `${sha}^`,
+    sha,
+    "--unified=0"
+  ]);
+  let raw = result.stdout;
+  if (result.exitCode !== 0) {
+    const emptyTree = await runGit(repoRoot, [
+      "diff",
+      "4b825dc642cb6eb9a060e54bf8d69288fbee4904",
+      sha,
+      "--unified=0"
+    ]);
+    raw = emptyTree.stdout;
+  }
+  return { files, raw };
+}
+// src/lib/git/gitConfig.ts
+async function configureNotesSync(_repoRoot) {
+  return true;
+}
+async function removeNotesSync(repoRoot) {
+  try {
+    await runGit(repoRoot, [
+      "config",
+      "--local",
+      "--unset-all",
+      "remote.origin.push",
+      "refs/notes/agentblame"
+    ]).catch(() => {});
+    await runGit(repoRoot, [
+      "config",
+      "--local",
+      "--unset-all",
+      "remote.origin.fetch",
+      "refs/notes/agentblame"
+    ]).catch(() => {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+// src/sync.ts
+function run(cmd, cwd) {
+  try {
+    return execSync(cmd, { encoding: "utf8", cwd }).trim();
+  } catch {
+    return "";
+  }
+}
+function vlog(msg, options) {
+  if (options.verbose) {
+    console.log(`  ${msg}`);
+  }
+}
+function findMergeCandidates(repoRoot, options) {
+  const candidates = [];
+  const logOutput = run(`git log --oneline -20 --format="%H %s"`, repoRoot);
+  if (!logOutput)
+    return candidates;
+  for (const line of logOutput.split(`
+`)) {
+    const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
+    if (!match)
+      continue;
+    const [, sha, message] = match;
+    const prMatch = message.match(/\(#?(\d+)\)\s*$/);
+    if (!prMatch)
+      continue;
+    const prNumber = parseInt(prMatch[1], 10);
+    const hasNote = run(`git notes --ref=refs/notes/agentblame show ${sha} 2>/dev/null`, repoRoot);
+    if (hasNote) {
+      vlog(`Skipping ${sha.slice(0, 7)} - already has note`, options);
+      continue;
+    }
+    const parents = run(`git rev-list --parents -n 1 ${sha}`, repoRoot).split(" ");
+    if (parents.length > 2) {
+      vlog(`Skipping ${sha.slice(0, 7)} - merge commit (has multiple parents)`, options);
+      continue;
+    }
+    candidates.push({ sha, prNumber, message });
+  }
+  return candidates;
+}
+function fetchPRRef(repoRoot, prNumber, options) {
+  vlog(`Fetching refs/pull/${prNumber}/head...`, options);
+  run(`git fetch origin refs/pull/${prNumber}/head:refs/remotes/origin/pr/${prNumber} 2>&1`, repoRoot);
+  const refExists = run(`git rev-parse --verify refs/remotes/origin/pr/${prNumber} 2>/dev/null`, repoRoot);
+  return !!refExists;
+}
+function getPRCommits(repoRoot, prNumber, baseSha) {
+  const prRef = `refs/remotes/origin/pr/${prNumber}`;
+  const output = run(`git rev-list ${baseSha}..${prRef} 2>/dev/null`, repoRoot);
+  if (!output)
+    return [];
+  return output.split(`
+`).filter(Boolean);
+}
+function readNote2(repoRoot, sha) {
+  const note = run(`git notes --ref=refs/notes/agentblame show ${sha} 2>/dev/null`, repoRoot);
+  if (!note)
+    return null;
+  try {
+    return JSON.parse(note);
+  } catch {
+    return null;
+  }
+}
+function writeNote(repoRoot, sha, attribution) {
+  const noteJson = JSON.stringify(attribution);
+  try {
+    const result = spawnSync("git", ["notes", "--ref=refs/notes/agentblame", "add", "-f", "-m", noteJson, sha], { encoding: "utf8", cwd: repoRoot });
+    if (result.status !== 0) {
+      console.error(`Failed to write note to ${sha}: ${result.stderr}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    console.error(`Failed to write note to ${sha}: ${err}`);
+    return false;
+  }
+}
+function getCommitHunks(repoRoot, sha) {
+  const diff2 = run(`git diff-tree -p ${sha}`, repoRoot);
+  if (!diff2)
+    return [];
+  const hunks = [];
+  let currentFile = "";
+  let lineNumber = 0;
+  let addedLines = [];
+  let startLine = 0;
+  const computeHash = (content) => {
+    const crypto = __require("crypto");
+    return `sha256:${crypto.createHash("sha256").update(content).digest("hex")}`;
+  };
+  for (const line of diff2.split(`
+`)) {
+    if (line.startsWith("+++ b/")) {
+      if (addedLines.length > 0 && currentFile) {
+        const content = addedLines.join(`
+`);
+        hunks.push({
+          path: currentFile,
+          startLine,
+          content,
+          contentHash: computeHash(content)
+        });
+        addedLines = [];
+      }
+      currentFile = line.slice(6);
+      continue;
+    }
+    if (line.startsWith("@@")) {
+      if (addedLines.length > 0 && currentFile) {
+        const content = addedLines.join(`
+`);
+        hunks.push({
+          path: currentFile,
+          startLine,
+          content,
+          contentHash: computeHash(content)
+        });
+        addedLines = [];
+      }
+      const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)/);
+      if (match) {
+        lineNumber = parseInt(match[1], 10);
+        startLine = lineNumber;
+      }
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      if (addedLines.length === 0) {
+        startLine = lineNumber;
+      }
+      addedLines.push(line.slice(1));
+      lineNumber++;
+      continue;
+    }
+    if (!line.startsWith("-")) {
+      if (addedLines.length > 0 && currentFile) {
+        const content = addedLines.join(`
+`);
+        hunks.push({
+          path: currentFile,
+          startLine,
+          content,
+          contentHash: computeHash(content)
+        });
+        addedLines = [];
+      }
+      lineNumber++;
+    }
+  }
+  if (addedLines.length > 0 && currentFile) {
+    const content = addedLines.join(`
+`);
+    hunks.push({
+      path: currentFile,
+      startLine,
+      content,
+      contentHash: computeHash(content)
+    });
+  }
+  return hunks;
+}
+function collectPRAttributions(repoRoot, prCommits) {
+  const byHash = new Map;
+  const withContent = [];
+  for (const sha of prCommits) {
+    const note = readNote2(repoRoot, sha);
+    if (!note?.attributions)
+      continue;
+    const hunks = getCommitHunks(repoRoot, sha);
+    const hunksByHash = new Map;
+    for (const hunk of hunks) {
+      hunksByHash.set(hunk.contentHash, hunk.content);
+    }
+    for (const attr of note.attributions) {
+      const hash = attr.contentHash;
+      if (!byHash.has(hash)) {
+        byHash.set(hash, []);
+      }
+      byHash.get(hash)?.push(attr);
+      const content = hunksByHash.get(hash) || "";
+      if (content) {
+        withContent.push({ ...attr, originalContent: content });
+      }
+    }
+  }
+  return { byHash, withContent };
+}
+function findContainedAttributions(hunk, attributions) {
+  const results = [];
+  for (const attr of attributions) {
+    const attrFileName = attr.path.split("/").pop();
+    const hunkFileName = hunk.path.split("/").pop();
+    const sameFile = attrFileName === hunkFileName || attr.path.endsWith(hunk.path) || hunk.path.endsWith(attrFileName || "");
+    if (!sameFile)
+      continue;
+    const aiContent = attr.originalContent.trim();
+    const hunkContent = hunk.content;
+    if (!hunkContent.includes(aiContent))
+      continue;
+    const offset = hunkContent.indexOf(aiContent);
+    let startLine = hunk.startLine;
+    if (offset > 0) {
+      const contentBeforeAI = hunkContent.slice(0, offset);
+      const linesBeforeAI = contentBeforeAI.split(`
+`).length - 1;
+      startLine = hunk.startLine + linesBeforeAI;
+    }
+    const aiLineCount = aiContent.split(`
+`).length;
+    const endLine = startLine + aiLineCount - 1;
+    const { originalContent: _, ...cleanAttr } = attr;
+    results.push({
+      ...cleanAttr,
+      path: hunk.path,
+      startLine,
+      endLine
+    });
+  }
+  return results;
+}
+function transferNotes(repoRoot, candidate, prCommits, options) {
+  const { byHash, withContent } = collectPRAttributions(repoRoot, prCommits);
+  if (byHash.size === 0) {
+    vlog(`No attributions found in PR commits`, options);
+    return 0;
+  }
+  vlog(`Found ${byHash.size} unique content hashes`, options);
+  const hunks = getCommitHunks(repoRoot, candidate.sha);
+  vlog(`Merge commit has ${hunks.length} hunks`, options);
+  const newAttributions = [];
+  const matchedHashes = new Set;
+  for (const hunk of hunks) {
+    const attrs = byHash.get(hunk.contentHash);
+    if (attrs && attrs.length > 0) {
+      const attr = attrs[0];
+      newAttributions.push({
+        ...attr,
+        path: hunk.path,
+        startLine: hunk.startLine,
+        endLine: hunk.startLine + hunk.content.split(`
+`).length - 1
+      });
+      matchedHashes.add(attr.contentHash);
+      vlog(`  Exact match: ${hunk.path}:${hunk.startLine}`, options);
+      continue;
+    }
+    const unmatchedAttrs = withContent.filter((a) => !matchedHashes.has(a.contentHash));
+    const containedMatches = findContainedAttributions(hunk, unmatchedAttrs);
+    for (const match of containedMatches) {
+      newAttributions.push(match);
+      matchedHashes.add(match.contentHash);
+      vlog(`  Contained match: ${match.path}:${match.startLine}-${match.endLine}`, options);
+    }
+  }
+  if (newAttributions.length === 0) {
+    return 0;
+  }
+  if (options.dryRun) {
+    console.log(`  Would attach ${newAttributions.length} attribution(s)`);
+    return newAttributions.length;
+  }
+  const note = {
+    version: 2,
+    timestamp: new Date().toISOString(),
+    attributions: newAttributions
+  };
+  if (writeNote(repoRoot, candidate.sha, note)) {
+    return newAttributions.length;
+  }
+  return 0;
+}
+function findBaseSha(repoRoot, mergeSha) {
+  const parent = run(`git rev-parse ${mergeSha}^`, repoRoot);
+  return parent || "";
+}
+function pushNotes(repoRoot, options) {
+  if (options.dryRun) {
+    console.log(`
+Would push notes to origin`);
+    return true;
+  }
+  console.log(`
+Pushing notes to origin...`);
+  try {
+    execSync("git push origin refs/notes/agentblame", {
+      encoding: "utf8",
+      cwd: repoRoot,
+      stdio: "inherit"
+    });
+    return true;
+  } catch {
+    console.error("Failed to push notes");
+    return false;
+  }
+}
+async function sync(options = {}) {
+  const repoRoot = await getRepoRoot(process.cwd());
+  if (!repoRoot) {
+    console.error("Error: Not in a git repository");
+    process.exit(1);
+  }
+  console.log(`Agent Blame Sync - Transferring attribution notes
+`);
+  if (options.dryRun) {
+    console.log(`[DRY RUN - no changes will be made]
+`);
+  }
+  await fetchNotesQuiet(repoRoot, "origin", options.verbose);
+  const candidates = findMergeCandidates(repoRoot, options);
+  if (candidates.length === 0) {
+    console.log("No squash/rebase merges found that need notes transferred.");
+    console.log("(Looking for commits with PR numbers like '#123' that don't have notes)");
+    return;
+  }
+  console.log(`Found ${candidates.length} merge(s) that may need notes:
+`);
+  let totalTransferred = 0;
+  let successCount = 0;
+  for (const candidate of candidates) {
+    console.log(`PR #${candidate.prNumber}: ${candidate.message.slice(0, 50)}...`);
+    console.log(`  Commit: ${candidate.sha.slice(0, 7)}`);
+    if (!fetchPRRef(repoRoot, candidate.prNumber, options)) {
+      console.log(`  Skipped: Could not fetch PR #${candidate.prNumber} refs`);
+      continue;
+    }
+    const baseSha = findBaseSha(repoRoot, candidate.sha);
+    if (!baseSha) {
+      console.log(`  Skipped: Could not find base commit`);
+      continue;
+    }
+    const prCommits = getPRCommits(repoRoot, candidate.prNumber, baseSha);
+    if (prCommits.length === 0) {
+      console.log(`  Skipped: No PR commits found`);
+      continue;
+    }
+    vlog(`Found ${prCommits.length} PR commits`, options);
+    const transferred = transferNotes(repoRoot, candidate, prCommits, options);
+    if (transferred > 0) {
+      console.log(`  Transferred ${transferred} attribution(s)`);
+      totalTransferred += transferred;
+      successCount++;
+    } else {
+      console.log(`  No attributions to transfer`);
+    }
+    console.log("");
+  }
+  if (totalTransferred > 0) {
+    console.log(`
+Summary: Transferred ${totalTransferred} attribution(s) for ${successCount} merge(s)`);
+    pushNotes(repoRoot, options);
+  } else {
+    console.log(`
+No attributions were transferred.`);
+  }
+}
+
+// src/process.ts
+var c2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  orange: "\x1B[38;2;184;101;64m",
+  blue: "\x1B[34m"
+};
+async function processCommit(repoRoot, commitSha) {
+  const parentSha = await getParentCommit(repoRoot, commitSha);
+  if (!parentSha) {
+    return {
+      sha: commitSha,
+      filesProcessed: 0,
+      aiLines: 0,
+      humanLines: 0,
+      sessions: []
+    };
+  }
+  const diff2 = await getCommitDiff(repoRoot, commitSha);
+  const trackedFiles = getModifiedFiles(repoRoot, parentSha);
+  const fileAttributions = new Map;
+  let totalAiLines = 0;
+  let totalHumanLines = 0;
+  const allSessionIds = new Set;
+  for (const file of diff2.files || []) {
+    if (file.status === "deleted")
+      continue;
+    const committedContent = await getFileAtCommit(repoRoot, commitSha, file.path);
+    if (!committedContent)
+      continue;
+    const committedLines = committedContent.split(`
+`);
+    if (!trackedFiles.includes(file.path)) {
+      const humanAttrs = committedLines.map((_, i) => ({
+        line: i + 1,
+        sessionId: null
+      }));
+      fileAttributions.set(file.path, humanAttrs);
+      totalHumanLines += committedLines.length;
+      continue;
+    }
+    const chain = getSnapshotChainForFile(repoRoot, parentSha, file.path);
+    if (chain.length === 0) {
+      const humanAttrs = committedLines.map((_, i) => ({
+        line: i + 1,
+        sessionId: null
+      }));
+      fileAttributions.set(file.path, humanAttrs);
+      totalHumanLines += committedLines.length;
+      continue;
+    }
+    const origins = await traceFileLines(repoRoot, committedLines, chain);
+    const attrs = [];
+    for (let i = 0;i < origins.length; i++) {
+      const origin = origins[i];
+      attrs.push({
+        line: i + 1,
+        sessionId: origin.sessionId
+      });
+      if (origin.sessionId) {
+        totalAiLines++;
+        allSessionIds.add(origin.sessionId);
+      } else {
+        totalHumanLines++;
+      }
+    }
+    fileAttributions.set(file.path, attrs);
+  }
+  const sessionMap = buildSessionMap(fileAttributions);
+  const humanMap = buildHumanMap(fileAttributions);
+  const attribution = {
+    version: 3,
+    timestamp: new Date().toISOString(),
+    sessions: {},
+    files: {}
+  };
+  const sessions = {};
+  for (const sessionId of allSessionIds) {
+    const session = getSession(sessionId);
+    const prompt = getLatestPromptForSession(sessionId);
+    const tools = getToolNamesForSession(sessionId);
+    sessions[sessionId] = {
+      a: session?.agent || "cursor",
+      m: session?.model || null,
+      p: prompt?.content || null,
+      t: session?.createdAt || new Date().toISOString(),
+      tools
+    };
+    updateSessionFirstCommit(sessionId, commitSha);
+  }
+  attribution.sessions = sessions;
+  for (const [filePath, attrs] of fileAttributions) {
+    const ranges = aggregateToRanges(attrs);
+    const { aiRanges, humanRanges } = separateRanges(ranges);
+    attribution.files[filePath] = {
+      aiRanges: aiRanges.map((r) => ({
+        sessionId: r.sessionId,
+        startLine: r.startLine,
+        endLine: r.endLine
+      })),
+      humanRanges
+    };
+  }
+  if (allSessionIds.size > 0 || Object.keys(attribution.files).length > 0) {
+    await attachNoteV3(repoRoot, commitSha, attribution, sessions);
+  }
+  const commitStats = computeCommitStats(sessions, attribution.files);
+  const authorResult = await runGit(repoRoot, [
+    "log",
+    "-1",
+    "--format=%ae",
+    commitSha
+  ]);
+  const commitAuthor = authorResult.exitCode === 0 ? authorResult.stdout.trim() : undefined;
+  await updateAnalytics(repoRoot, commitStats, commitAuthor);
+  cleanupWorkingDir(repoRoot, parentSha);
+  return {
+    sha: commitSha,
+    filesProcessed: fileAttributions.size,
+    aiLines: totalAiLines,
+    humanLines: totalHumanLines,
+    sessions: Array.from(allSessionIds)
+  };
+}
+async function runProcess(sha) {
+  const repoRoot = await getRepoRoot(process.cwd());
+  if (!repoRoot) {
+    console.error("Error: Not in a git repository");
+    process.exit(1);
+  }
+  const dbPath = getDatabasePath(repoRoot);
+  setDatabasePath(dbPath);
+  await fetchNotesQuiet(repoRoot);
+  let commitSha = sha || "HEAD";
+  const resolveResult = await runGit(repoRoot, ["rev-parse", commitSha]);
+  if (resolveResult.exitCode !== 0) {
+    console.error("Error: Could not resolve commit");
+    process.exit(1);
+  }
+  commitSha = resolveResult.stdout.trim();
+  const result = await processCommit(repoRoot, commitSha);
+  const totalLines = result.aiLines + result.humanLines;
+  const aiPercent = totalLines > 0 ? Math.round(result.aiLines / totalLines * 100) : 0;
+  const humanPercent = 100 - aiPercent;
+  const WIDTH = 72;
+  const INNER = WIDTH - 2;
+  const border = `${c2.dim}\u2502${c2.reset}`;
+  const padRight = (content, visibleLen) => content + " ".repeat(Math.max(0, INNER - visibleLen));
+  console.log("");
+  console.log(`${c2.dim}\u250C${"\u2500".repeat(WIDTH - 2)}\u2510${c2.reset}`);
+  const title = "Agent Blame v3";
+  const titlePadLeft = Math.floor((INNER - title.length) / 2);
+  const titlePadRight = INNER - title.length - titlePadLeft;
+  console.log(`${border}${" ".repeat(titlePadLeft)}${c2.bold}${c2.cyan}${title}${c2.reset}${" ".repeat(titlePadRight)}${border}`);
+  console.log(`${c2.dim}\u251C${"\u2500".repeat(WIDTH - 2)}\u2524${c2.reset}`);
+  const commitVisible = `  Commit: ${commitSha.slice(0, 8)}`;
+  const commitColored = `  ${c2.yellow}Commit: ${commitSha.slice(0, 8)}${c2.reset}`;
+  console.log(`${border}${padRight(commitColored, commitVisible.length)}${border}`);
+  const filesVisible = `  Files: ${result.filesProcessed}`;
+  console.log(`${border}${padRight(filesVisible, filesVisible.length)}${border}`);
+  console.log(`${c2.dim}\u251C${"\u2500".repeat(WIDTH - 2)}\u2524${c2.reset}`);
+  if (result.sessions.length > 0) {
+    const sessHeader = "  Sessions:";
+    console.log(`${border}${padRight(sessHeader, sessHeader.length)}${border}`);
+    for (const sessionId of result.sessions) {
+      const session = getSession(sessionId);
+      const agent = session?.agent || "unknown";
+      const model = session?.model || "";
+      const modelStr = model ? ` - ${model}` : "";
+      const visibleText = `    ${sessionId.slice(0, 8)} [${agent}${modelStr}]`;
+      const coloredText = `    ${c2.blue}${sessionId.slice(0, 8)}${c2.reset} ${c2.orange}[${agent}${modelStr}]${c2.reset}`;
+      console.log(`${border}${padRight(coloredText, visibleText.length)}${border}`);
+      const prompt = getLatestPromptForSession(sessionId);
+      if (prompt) {
+        const truncatedPrompt = prompt.content.length > 50 ? prompt.content.substring(0, 50) + "..." : prompt.content;
+        const promptVisible = `      "${truncatedPrompt}"`;
+        const promptColored = `      ${c2.dim}"${truncatedPrompt}"${c2.reset}`;
+        console.log(`${border}${padRight(promptColored, promptVisible.length)}${border}`);
+      }
+    }
+    console.log(`${c2.dim}\u251C${"\u2500".repeat(WIDTH - 2)}\u2524${c2.reset}`);
+  }
+  const barWidth = 50;
+  const aiBarWidth = Math.round(aiPercent / 100 * barWidth);
+  const humanBarWidth = barWidth - aiBarWidth;
+  const summaryHeader = "  Summary:";
+  console.log(`${border}${padRight(summaryHeader, summaryHeader.length)}${border}`);
+  const barVisible = `  ${"\u2588".repeat(aiBarWidth)}${"\u2591".repeat(humanBarWidth)}`;
+  const barColored = `  ${c2.orange}${"\u2588".repeat(aiBarWidth)}${c2.reset}${c2.dim}${"\u2591".repeat(humanBarWidth)}${c2.reset}`;
+  console.log(`${border}${padRight(barColored, barVisible.length)}${border}`);
+  const statsVisible = `  AI: ${String(result.aiLines).padStart(3)} lines (${String(aiPercent).padStart(3)}%)    Human: ${String(result.humanLines).padStart(3)} lines (${String(humanPercent).padStart(3)}%)`;
+  const statsColored = `  ${c2.orange}AI: ${String(result.aiLines).padStart(3)} lines (${String(aiPercent).padStart(3)}%)${c2.reset}    ${c2.green}Human: ${String(result.humanLines).padStart(3)} lines (${String(humanPercent).padStart(3)}%)${c2.reset}`;
+  console.log(`${border}${padRight(statsColored, statsVisible.length)}${border}`);
+  console.log(`${c2.dim}\u2514${"\u2500".repeat(WIDTH - 2)}\u2518${c2.reset}`);
+  console.log("");
+}
+
+// src/capture.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+async function findRepoRoot(filePath) {
+  let dir = path6.dirname(filePath);
+  while (dir !== "/" && dir !== ".") {
+    const gitDir = path6.join(dir, ".git");
+    if (fs6.existsSync(gitDir)) {
+      return dir;
+    }
+    dir = path6.dirname(dir);
+  }
+  return null;
+}
+function makeRelative(repoRoot, filePath) {
+  if (filePath.startsWith(repoRoot)) {
+    return filePath.slice(repoRoot.length + 1);
+  }
+  return filePath;
+}
+async function extractModelFromTranscript(transcriptPath) {
+  try {
+    const content = fs6.readFileSync(transcriptPath, "utf8");
+    const lines = content.split(`
+`);
+    for (let i = lines.length - 1;i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line)
+        continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.message?.model) {
+          return entry.message.model;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function extractPromptFromTranscript(transcriptPath) {
+  try {
+    const content = fs6.readFileSync(transcriptPath, "utf8");
+    const lines = content.split(`
+`).reverse();
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "human" || entry.message?.role === "user") {
+          const msg = entry.message?.content;
+          if (Array.isArray(msg)) {
+            const textPart = msg.find((m) => m.type === "text" || typeof m === "string");
+            if (textPart) {
+              return typeof textPart === "string" ? textPart : textPart.text;
+            }
+          } else if (typeof msg === "string") {
+            return msg;
+          } else if (entry.content) {
+            return entry.content;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function setupCaptureContext(filePath, agent, conversationId, model) {
+  const repoRoot = await findRepoRoot(filePath);
+  if (!repoRoot) {
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error(`[agentblame] No git repo found for ${filePath}`);
+    }
+    return null;
+  }
+  ensureAgentBlameDirs(repoRoot);
+  const dbPath = getDatabasePath(repoRoot);
+  setDatabasePath(dbPath);
+  const baseSha = await getGitHead(repoRoot);
+  if (!baseSha) {
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error(`[agentblame] No HEAD commit found in ${repoRoot}`);
+    }
+    return null;
+  }
+  const sessionId = generateSessionId(agent, conversationId);
+  return {
+    repoRoot,
+    baseSha,
+    agent,
+    sessionId,
+    model
+  };
+}
+async function captureBeforeSnapshot(ctx, filePath) {
+  const absolutePath = path6.isAbsolute(filePath) ? filePath : path6.join(ctx.repoRoot, filePath);
+  const content = readFileContent(absolutePath);
+  if (content === null) {
+    return null;
+  }
+  try {
+    return await storeSnapshot(ctx.repoRoot, content);
+  } catch (err) {
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error(`[agentblame] Failed to store before snapshot:`, err);
+    }
+    return null;
+  }
+}
+async function captureAfterSnapshot(ctx, filePath) {
+  const absolutePath = path6.isAbsolute(filePath) ? filePath : path6.join(ctx.repoRoot, filePath);
+  const content = readFileContent(absolutePath);
+  if (content === null) {
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error(`[agentblame] File not found after edit: ${absolutePath}`);
+    }
+    return null;
+  }
+  try {
+    const blobSha = await storeSnapshot(ctx.repoRoot, content);
+    const relativePath = makeRelative(ctx.repoRoot, absolutePath);
+    const entry = {
+      ts: new Date().toISOString(),
+      file: relativePath,
+      blob: blobSha,
+      session: ctx.sessionId,
+      type: "ai_edit"
+    };
+    appendToWorkingLog(ctx.repoRoot, ctx.baseSha, entry);
+    return blobSha;
+  } catch (err) {
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error(`[agentblame] Failed to store after snapshot:`, err);
+    }
+    return null;
+  }
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let provider = "cursor";
+  let event;
+  for (let i = 0;i < args.length; i++) {
+    if (args[i] === "--provider" && args[i + 1]) {
+      provider = args[i + 1];
+      i++;
+    } else if (args[i] === "--event" && args[i + 1]) {
+      event = args[i + 1];
+      i++;
+    }
+  }
+  return { provider, event };
+}
+async function processCursorPayload(payload, event) {
+  if (event === "afterTabFileEdit") {
+    return;
+  }
+  if (!payload.edits || payload.edits.length === 0) {
+    return;
+  }
+  const filePath = payload.file_path;
+  if (!filePath)
+    return;
+  const conversationId = payload.conversation_id || `cursor-${Date.now()}`;
+  const ctx = await setupCaptureContext(filePath, "cursor", conversationId, payload.model || null);
+  if (!ctx)
+    return;
+  markAIEditStart(filePath);
+  try {
+    upsertSession({
+      id: ctx.sessionId,
+      agent: "cursor",
+      model: ctx.model,
+      conversationId
+    });
+    for (const edit of payload.edits) {
+      const oldString = edit.old_string || "";
+      const newString = edit.new_string || "";
+      if (!newString)
+        continue;
+      const beforeBlob = await captureBeforeSnapshot(ctx, filePath);
+      const afterBlob = await captureAfterSnapshot(ctx, filePath);
+      insertToolCall({
+        sessionId: ctx.sessionId,
+        toolName: "edit",
+        toolInput: JSON.stringify({
+          file_path: makeRelative(ctx.repoRoot, filePath),
+          old_string: oldString.substring(0, 500),
+          new_string: newString.substring(0, 500)
+        }),
+        filePath: makeRelative(ctx.repoRoot, filePath),
+        beforeBlob,
+        afterBlob
+      });
+      if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame] Captured Cursor edit: ${filePath} (before: ${beforeBlob}, after: ${afterBlob})`);
+      }
+    }
+  } finally {
+    markAIEditEnd(filePath);
+  }
+}
+async function processClaudePayload(payload) {
+  if (payload.cursor_version) {
+    return;
+  }
+  const toolName = payload.tool_name?.toLowerCase() || "";
+  if (toolName !== "edit" && toolName !== "write" && toolName !== "multiedit") {
+    return;
+  }
+  const toolInput = payload.tool_input;
+  const toolResponse = payload.tool_response;
+  const filePath = toolResponse?.filePath || toolInput?.file_path || payload.file_path;
+  if (!filePath)
+    return;
+  let model = null;
+  if (payload.transcript_path) {
+    model = await extractModelFromTranscript(payload.transcript_path);
+  }
+  if (!model) {
+    model = "claude";
+  }
+  const conversationId = payload.session_id || `claude-${Date.now()}`;
+  const ctx = await setupCaptureContext(filePath, "claude", conversationId, model);
+  if (!ctx)
+    return;
+  markAIEditStart(filePath);
+  try {
+    upsertSession({
+      id: ctx.sessionId,
+      agent: "claude",
+      model: ctx.model,
+      conversationId
+    });
+    if (payload.transcript_path) {
+      const prompt = await extractPromptFromTranscript(payload.transcript_path);
+      if (prompt && !promptExists(ctx.sessionId, prompt)) {
+        insertPrompt({
+          sessionId: ctx.sessionId,
+          content: prompt
+        });
+        if (process.env.AGENTBLAME_DEBUG) {
+          console.error(`[agentblame] Captured prompt: ${prompt.substring(0, 100)}...`);
+        }
+      }
+    }
+    const beforeBlob = await captureBeforeSnapshot(ctx, filePath);
+    const afterBlob = await captureAfterSnapshot(ctx, filePath);
+    let toolInputJson;
+    if (toolName === "write") {
+      toolInputJson = JSON.stringify({
+        file_path: makeRelative(ctx.repoRoot, filePath),
+        content: (toolInput?.content || "").substring(0, 500)
+      });
+    } else {
+      toolInputJson = JSON.stringify({
+        file_path: makeRelative(ctx.repoRoot, filePath),
+        old_string: (toolInput?.old_string || "").substring(0, 500),
+        new_string: (toolInput?.new_string || "").substring(0, 500)
+      });
+    }
+    insertToolCall({
+      sessionId: ctx.sessionId,
+      toolName: toolName === "multiedit" ? "MultiEdit" : toolName === "write" ? "Write" : "Edit",
+      toolInput: toolInputJson,
+      filePath: makeRelative(ctx.repoRoot, filePath),
+      beforeBlob,
+      afterBlob
+    });
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error(`[agentblame] Captured Claude ${toolName}: ${filePath} (before: ${beforeBlob}, after: ${afterBlob})`);
+    }
+  } finally {
+    markAIEditEnd(filePath);
+  }
+}
+async function processOpenCodePayload(payload) {
+  const filePath = payload.filePath;
+  if (!filePath)
+    return;
+  const conversationId = payload.sessionID || `opencode-${Date.now()}`;
+  const ctx = await setupCaptureContext(filePath, "opencode", conversationId, payload.model || null);
+  if (!ctx)
+    return;
+  markAIEditStart(filePath);
+  try {
+    upsertSession({
+      id: ctx.sessionId,
+      agent: "opencode",
+      model: ctx.model,
+      conversationId
+    });
+    if (payload.prompt && !promptExists(ctx.sessionId, payload.prompt)) {
+      insertPrompt({
+        sessionId: ctx.sessionId,
+        content: payload.prompt
+      });
+    }
+    const beforeBlob = await captureBeforeSnapshot(ctx, filePath);
+    const afterBlob = await captureAfterSnapshot(ctx, filePath);
+    let toolInputJson;
+    if (payload.tool === "write") {
+      toolInputJson = JSON.stringify({
+        file_path: makeRelative(ctx.repoRoot, filePath),
+        content: (payload.content || "").substring(0, 500)
+      });
+    } else {
+      toolInputJson = JSON.stringify({
+        file_path: makeRelative(ctx.repoRoot, filePath),
+        old_string: (payload.oldString || "").substring(0, 500),
+        new_string: (payload.newString || "").substring(0, 500)
+      });
+    }
+    insertToolCall({
+      sessionId: ctx.sessionId,
+      toolName: payload.tool === "write" ? "Write" : "Edit",
+      toolInput: toolInputJson,
+      filePath: makeRelative(ctx.repoRoot, filePath),
+      beforeBlob,
+      afterBlob
+    });
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error(`[agentblame] Captured OpenCode ${payload.tool}: ${filePath} (before: ${beforeBlob}, after: ${afterBlob})`);
+    }
+  } finally {
+    markAIEditEnd(filePath);
+  }
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function runCapture() {
+  try {
+    const { provider, event } = parseArgs();
+    const input = await readStdin();
+    if (!input.trim()) {
+      process.exit(0);
+    }
+    const data = JSON.parse(input);
+    const payload = data.payload || data;
+    if (provider === "cursor") {
+      const eventName = event || data.hook_event_name || "afterFileEdit";
+      await processCursorPayload(payload, eventName);
+    } else if (provider === "claude") {
+      await processClaudePayload(payload);
+    } else if (provider === "opencode") {
+      await processOpenCodePayload(payload);
+    }
+    process.exit(0);
+  } catch (err) {
+    if (process.env.AGENTBLAME_DEBUG) {
+      console.error("Agent Blame capture error:", err);
+    }
+    process.exit(0);
+  }
+}
+
+// src/index.ts
+var __dirname = "/Users/murali/Code/agentblame/packages/cli/src";
+var ANALYTICS_TAG = "agentblame-analytics-anchor";
+function isBunInstalled() {
+  try {
+    execSync2("bun --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var args = process.argv.slice(2);
+var command = args[0];
+async function main() {
+  switch (command) {
+    case "init":
+      await runInit(args.slice(1));
+      break;
+    case "clean":
+      await runClean(args.slice(1));
+      break;
+    case "capture":
+      await runCapture();
+      break;
+    case "blame":
+      await runBlame(args.slice(1));
+      break;
+    case "process":
+      await runProcess(args[1]);
+      break;
+    case "sync":
+      await runSync(args.slice(1));
+      break;
+    case "status":
+      await runStatus();
+      break;
+    case "prune":
+      await runPrune();
+      break;
+    case "migrate":
+      await runMigrate();
+      break;
+    case "--version":
+    case "-v":
+      printVersion();
+      break;
+    case "--help":
+    case "-h":
+    case undefined:
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`
+Agent Blame v3 - Track AI-generated code in your commits
+
+Usage:
+  agentblame init              Set up hooks for current repo
+  agentblame init --force      Set up hooks and clean up old global install
+  agentblame clean             Remove hooks from current repo
+  agentblame clean --force     Also clean up old global install
+  agentblame blame <file>      Show AI attribution for a file
+  agentblame blame --summary   Show summary only
+  agentblame blame --json      Output as JSON
+  agentblame status            Show session and capture stats
+  agentblame sync              Transfer notes after squash/rebase
+  agentblame prune             Remove old entries from database
+  agentblame migrate           Migrate from v2 to v3 schema
+
+Examples:
+  agentblame init
+  agentblame blame src/index.ts
+`);
+}
+function printVersion() {
+  const packageJsonPath = path7.join(__dirname, "..", "package.json");
+  try {
+    const packageJson = JSON.parse(fs7.readFileSync(packageJsonPath, "utf8"));
+    console.log(`agentblame v${packageJson.version}`);
+  } catch {
+    console.log("agentblame (version unknown)");
+  }
+}
+async function createAnalyticsTag(repoRoot) {
+  try {
+    const existingTag = await runGit(repoRoot, ["tag", "-l", ANALYTICS_TAG], 5000);
+    if (existingTag.stdout.trim()) {
+      return true;
+    }
+    const rootResult = await runGit(repoRoot, ["rev-list", "--max-parents=0", "HEAD"], 1e4);
+    if (rootResult.exitCode !== 0 || !rootResult.stdout.trim()) {
+      return false;
+    }
+    const rootLines = rootResult.stdout.trim().split(`
+`).filter(Boolean);
+    if (rootLines.length === 0) {
+      return false;
+    }
+    const rootSha = rootLines[0];
+    const tagResult = await runGit(repoRoot, ["tag", ANALYTICS_TAG, rootSha], 5000);
+    return tagResult.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function cleanupGlobalInstall() {
+  const results = { cursor: false, claude: false, db: false };
+  const home = os.homedir();
+  const globalCursorHooks = path7.join(home, ".cursor", "hooks.json");
+  try {
+    if (fs7.existsSync(globalCursorHooks)) {
+      const config = JSON.parse(await fs7.promises.readFile(globalCursorHooks, "utf8"));
+      if (config.hooks?.afterFileEdit) {
+        config.hooks.afterFileEdit = config.hooks.afterFileEdit.filter((h) => !h?.command?.includes("agentblame") && !h?.command?.includes("capture"));
+      }
+      await fs7.promises.writeFile(globalCursorHooks, JSON.stringify(config, null, 2), "utf8");
+      results.cursor = true;
+    }
+  } catch {}
+  const globalClaudeSettings = path7.join(home, ".claude", "settings.json");
+  try {
+    if (fs7.existsSync(globalClaudeSettings)) {
+      const config = JSON.parse(await fs7.promises.readFile(globalClaudeSettings, "utf8"));
+      if (config.hooks?.PostToolUse) {
+        config.hooks.PostToolUse = config.hooks.PostToolUse.filter((h) => !h?.hooks?.some((hh) => hh?.command?.includes("agentblame") || hh?.command?.includes("capture")));
+      }
+      await fs7.promises.writeFile(globalClaudeSettings, JSON.stringify(config, null, 2), "utf8");
+      results.claude = true;
+    }
+  } catch {}
+  const globalDb = path7.join(home, ".agentblame");
+  try {
+    if (fs7.existsSync(globalDb)) {
+      await fs7.promises.rm(globalDb, { recursive: true });
+      results.db = true;
+    }
+  } catch {}
+  return results;
+}
+async function runInit(initArgs = []) {
+  const forceCleanup = initArgs.includes("--force") || initArgs.includes("-f");
+  if (!isBunInstalled()) {
+    const installCmd = process.platform === "win32" ? 'powershell -c "irm bun.sh/install.ps1 | iex"' : "curl -fsSL https://bun.sh/install | bash";
+    console.log("");
+    console.log("  \x1B[31m\u2717\x1B[0m Bun is required but not installed");
+    console.log("");
+    console.log("  Agent Blame uses Bun to run hooks. Install it first:");
+    console.log("");
+    console.log(`    \x1B[36m${installCmd}\x1B[0m`);
+    console.log("");
+    console.log("  Then restart your terminal and run this command again.");
+    console.log("  Learn more: \x1B[36mhttps://bun.sh\x1B[0m");
+    console.log("");
+    process.exit(1);
+  }
+  const repoRoot = await getRepoRoot(process.cwd());
+  if (!repoRoot) {
+    console.log("");
+    console.log("  \x1B[31m\u2717\x1B[0m Not in a git repository");
+    console.log("");
+    console.log("  Run this command from inside a git repository.");
+    console.log("");
+    process.exit(1);
+  }
+  console.log("");
+  console.log("  \x1B[1m\x1B[35m\u25C6\x1B[0m \x1B[1mAgent Blame v3\x1B[0m");
+  console.log("  \x1B[2mTrack AI-generated code in your commits\x1B[0m");
+  console.log("");
+  const repoName = path7.basename(repoRoot);
+  console.log(`  \x1B[2mRepository:\x1B[0m ${repoName}`);
+  console.log("");
+  if (forceCleanup) {
+    console.log("  \x1B[2mCleaning up global install...\x1B[0m");
+    const cleanup = await cleanupGlobalInstall();
+    if (cleanup.cursor)
+      console.log("  \x1B[32m\u2713\x1B[0m Removed global Cursor hooks");
+    if (cleanup.claude)
+      console.log("  \x1B[32m\u2713\x1B[0m Removed global Claude hooks");
+    if (cleanup.db)
+      console.log("  \x1B[32m\u2713\x1B[0m Removed global database");
+    if (!cleanup.cursor && !cleanup.claude && !cleanup.db) {
+      console.log("  \x1B[2m  No global install found\x1B[0m");
+    }
+    console.log("");
+  }
+  const results = [];
+  try {
+    ensureAgentBlameDirs(repoRoot);
+    const dbPath = getDatabasePath(repoRoot);
+    setDatabasePath(dbPath);
+    initDatabase();
+    results.push({ name: "Database (.git/agentblame/)", success: true });
+  } catch (err) {
+    results.push({ name: "Database", success: false });
+  }
+  try {
+    await initAnalytics(repoRoot);
+    results.push({ name: "Analytics", success: true });
+  } catch {
+    results.push({ name: "Analytics", success: false });
+  }
+  try {
+    const gitignorePath = path7.join(repoRoot, ".gitignore");
+    let gitignoreContent = "";
+    if (fs7.existsSync(gitignorePath)) {
+      gitignoreContent = await fs7.promises.readFile(gitignorePath, "utf8");
+    }
+    let entriesToAdd = "";
+    if (!gitignoreContent.includes(".agentblame")) {
+      entriesToAdd += `
+# Agent Blame local database (legacy)
+.agentblame/
+`;
+    }
+    if (!gitignoreContent.includes(".opencode")) {
+      entriesToAdd += `
+# OpenCode local plugin (installed by agentblame init)
+.opencode/
+`;
+    }
+    if (entriesToAdd) {
+      await fs7.promises.appendFile(gitignorePath, entriesToAdd);
+    }
+    results.push({ name: "Updated .gitignore", success: true });
+  } catch {
+    results.push({ name: "Updated .gitignore", success: false });
+  }
+  const cursorSuccess = await installCursorHooks(repoRoot);
+  results.push({ name: "Cursor hooks", success: cursorSuccess });
+  const claudeSuccess = await installClaudeHooks(repoRoot);
+  results.push({ name: "Claude Code hooks", success: claudeSuccess });
+  const opencodeSuccess = await installOpenCodeHooks(repoRoot);
+  results.push({ name: "OpenCode hooks", success: opencodeSuccess });
+  const gitHookSuccess = await installGitHook(repoRoot);
+  results.push({ name: "Git post-commit hook", success: gitHookSuccess });
+  const notesPushSuccess = await configureNotesSync(repoRoot);
+  results.push({ name: "Notes auto-push", success: notesPushSuccess });
+  const githubActionSuccess = await installGitHubAction(repoRoot);
+  results.push({ name: "GitHub Actions workflow", success: githubActionSuccess });
+  const analyticsTagSuccess = await createAnalyticsTag(repoRoot);
+  results.push({ name: "Analytics anchor tag", success: analyticsTagSuccess });
+  console.log("  \x1B[2m\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m");
+  console.log("");
+  for (const result of results) {
+    const icon = result.success ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    console.log(`  ${icon} ${result.name}`);
+  }
+  const allSuccess = results.every((r) => r.success);
+  const anySuccess = results.some((r) => r.success);
+  console.log("");
+  console.log("  \x1B[2m\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m");
+  console.log("");
+  if (allSuccess) {
+    console.log("  \x1B[32m\u2713\x1B[0m \x1B[1mSetup complete\x1B[0m");
+  } else if (anySuccess) {
+    console.log("  \x1B[33m!\x1B[0m \x1B[1mSetup completed with warnings\x1B[0m");
+  } else {
+    console.log("  \x1B[31m\u2717\x1B[0m \x1B[1mSetup failed\x1B[0m");
+  }
+  console.log("");
+  console.log("  \x1B[1mNext steps:\x1B[0m");
+  console.log("  \x1B[33m1.\x1B[0m Commit \x1B[36m.github/workflows/agentblame.yml\x1B[0m to enable PR analytics");
+  console.log("  \x1B[33m2.\x1B[0m Restart Cursor or Claude Code to pick up hooks");
+  console.log("  \x1B[33m3.\x1B[0m Make AI edits and commit your changes");
+  console.log("  \x1B[33m4.\x1B[0m Run \x1B[36magentblame blame <file>\x1B[0m to see attribution");
+  console.log("");
+}
+async function runClean(uninstallArgs = []) {
+  const forceCleanup = uninstallArgs.includes("--force") || uninstallArgs.includes("-f");
+  const repoRoot = await getRepoRoot(process.cwd());
+  if (!repoRoot) {
+    console.log("");
+    console.log("  \x1B[31m\u2717\x1B[0m Not in a git repository");
+    console.log("");
+    console.log("  Run this command from inside a git repository.");
+    console.log("");
+    process.exit(1);
+  }
+  console.log("");
+  console.log("  \x1B[1m\x1B[35m\u25C6\x1B[0m \x1B[1mAgent Blame\x1B[0m");
+  console.log("  \x1B[2mRemoving hooks and configuration\x1B[0m");
+  console.log("");
+  const repoName = path7.basename(repoRoot);
+  console.log(`  \x1B[2mRepository:\x1B[0m ${repoName}`);
+  console.log("");
+  if (forceCleanup) {
+    console.log("  \x1B[2mCleaning up global install...\x1B[0m");
+    const cleanup = await cleanupGlobalInstall();
+    if (cleanup.cursor)
+      console.log("  \x1B[32m\u2713\x1B[0m Removed global Cursor hooks");
+    if (cleanup.claude)
+      console.log("  \x1B[32m\u2713\x1B[0m Removed global Claude hooks");
+    if (cleanup.db)
+      console.log("  \x1B[32m\u2713\x1B[0m Removed global database");
+    if (!cleanup.cursor && !cleanup.claude && !cleanup.db) {
+      console.log("  \x1B[2m  No global install found\x1B[0m");
+    }
+    console.log("");
+  }
+  const results = [];
+  const cursorSuccess = await uninstallCursorHooks(repoRoot);
+  results.push({ name: "Cursor hooks", success: cursorSuccess });
+  const claudeSuccess = await uninstallClaudeHooks(repoRoot);
+  results.push({ name: "Claude Code hooks", success: claudeSuccess });
+  const opencodeSuccess = await uninstallOpenCodeHooks(repoRoot);
+  results.push({ name: "OpenCode hooks", success: opencodeSuccess });
+  const gitHookSuccess = await uninstallGitHook(repoRoot);
+  results.push({ name: "Git post-commit hook", success: gitHookSuccess });
+  const notesPushSuccess = await removeNotesSync(repoRoot);
+  results.push({ name: "Notes auto-push", success: notesPushSuccess });
+  const githubActionSuccess = await uninstallGitHubAction(repoRoot);
+  results.push({ name: "GitHub Actions workflow", success: githubActionSuccess });
+  const agentBlameGitDir = getAgentBlameGitDir(repoRoot);
+  let dbSuccess = true;
+  try {
+    if (fs7.existsSync(agentBlameGitDir)) {
+      await fs7.promises.rm(agentBlameGitDir, { recursive: true });
+    }
+  } catch {
+    dbSuccess = false;
+  }
+  results.push({ name: "Database (.git/agentblame/)", success: dbSuccess });
+  const legacyDir = path7.join(repoRoot, ".agentblame");
+  try {
+    if (fs7.existsSync(legacyDir)) {
+      await fs7.promises.rm(legacyDir, { recursive: true });
+      results.push({ name: "Legacy database (.agentblame/)", success: true });
+    }
+  } catch {}
+  console.log("  \x1B[2m\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m");
+  console.log("");
+  for (const result of results) {
+    const icon = result.success ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    console.log(`  ${icon} ${result.name}`);
+  }
+  const allSuccess = results.every((r) => r.success);
+  console.log("");
+  console.log("  \x1B[2m\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m");
+  console.log("");
+  if (allSuccess) {
+    console.log("  \x1B[32m\u2713\x1B[0m \x1B[1mUninstall complete\x1B[0m");
+  } else {
+    console.log("  \x1B[33m!\x1B[0m \x1B[1mUninstall completed with warnings\x1B[0m");
+  }
+  console.log("");
+}
+async function runBlame(args2) {
+  const options = {};
+  let filePath;
+  for (const arg of args2) {
+    if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--summary") {
+      options.summary = true;
+    } else if (arg === "--prompts" || arg === "-p") {
+      options.showPrompts = true;
+    } else if (!arg.startsWith("-")) {
+      filePath = arg;
+    }
+  }
+  if (!filePath) {
+    console.error("Usage: agentblame blame [--json|--summary|--prompts] <file>");
+    process.exit(1);
+  }
+  await blame(filePath, options);
+}
+async function runSync(args2) {
+  const options = {};
+  for (const arg of args2) {
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else if (arg === "--verbose" || arg === "-v") {
+      options.verbose = true;
+    }
+  }
+  await sync(options);
+}
+async function runStatus() {
+  const repoRoot = await getRepoRoot(process.cwd());
+  if (!repoRoot) {
+    console.error("Not in a git repository");
+    process.exit(1);
+  }
+  const dbPath = getDatabasePath(repoRoot);
+  setDatabasePath(dbPath);
+  console.log(`
+Agent Blame v3 Status
+`);
+  try {
+    const stats = getStats();
+    console.log(`Sessions: ${stats.sessions}`);
+    console.log(`Prompts:  ${stats.prompts}`);
+    console.log(`Tool Calls: ${stats.toolCalls}`);
+    if (stats.sessions > 0) {
+      console.log(`
+Recent sessions:`);
+      const recent = getRecentSessions(5);
+      for (const session of recent) {
+        const time = new Date(session.createdAt).toLocaleTimeString();
+        const agent = session.agent;
+        const model = session.model || "";
+        const committed = session.firstCommitSha ? "committed" : "pending";
+        console.log(`  [${agent}] ${session.id.slice(0, 8)} - ${model || "unknown"} (${committed}) at ${time}`);
+      }
+      if (stats.sessions > 5) {
+        console.log(`  ... and ${stats.sessions - 5} more`);
+      }
+    }
+  } catch (err) {
+    console.log("  No database found. Run 'agentblame init' first.");
+  }
+  console.log("");
+}
+async function runPrune() {
+  const repoRoot = await getRepoRoot(process.cwd());
+  if (!repoRoot) {
+    console.error("Not in a git repository");
+    process.exit(1);
+  }
+  const dbPath = getDatabasePath(repoRoot);
+  setDatabasePath(dbPath);
+  console.log(`
+Agent Blame Prune
+`);
+  const dbResult = cleanupOldEntries();
+  console.log(`  Database: Removed ${dbResult.removed} sessions, kept ${dbResult.kept}`);
+  const workingResult = await cleanupStaleWorkingDirs(repoRoot);
+  console.log(`  Working dirs: Cleaned ${workingResult.cleaned.length}, kept ${workingResult.kept.length}`);
+  console.log(`
+Prune complete!`);
+}
+async function runMigrate() {
+  const repoRoot = await getRepoRoot(process.cwd());
+  if (!repoRoot) {
+    console.error("Not in a git repository");
+    process.exit(1);
+  }
+  console.log(`
+Agent Blame v3 Migration
+`);
+  ensureAgentBlameDirs(repoRoot);
+  const dbPath = getDatabasePath(repoRoot);
+  setDatabasePath(dbPath);
+  console.log("  Resetting database to v3 schema...");
+  resetDatabase();
+  console.log("  \x1B[32m\u2713\x1B[0m Database migrated");
+  console.log("  Initializing analytics...");
+  await initAnalytics(repoRoot);
+  console.log("  \x1B[32m\u2713\x1B[0m Analytics initialized");
+  const legacyDir = path7.join(repoRoot, ".agentblame");
+  if (fs7.existsSync(legacyDir)) {
+    console.log("  Removing legacy database...");
+    await fs7.promises.rm(legacyDir, { recursive: true });
+    console.log("  \x1B[32m\u2713\x1B[0m Legacy database removed");
+  }
+  console.log(`
+\x1B[32m\u2713\x1B[0m Migration complete!`);
+  console.log(`
+Note: Existing v2 git notes remain readable.`);
+  console.log(`New commits will use the v3 format.
+`);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});