@wasabeef/agentnote 0.1.6 → 0.1.7

package/dist/cli.js

@@ -25,12 +25,18 @@ var TRUNCATE_PROMPT = 120;
 var TRUNCATE_RESPONSE_SHOW = 200;
 var TRUNCATE_RESPONSE_PR = 500;
 var TRUNCATE_RESPONSE_CHAT = 800;
+var ARCHIVE_ID_RE = /^[0-9a-z]{6,}$/;
+var HEARTBEAT_FILE = "heartbeat";
+var PRE_BLOBS_FILE = "pre_blobs.jsonl";
+var COMMITTED_PAIRS_FILE = "committed_pairs.jsonl";
+var EMPTY_BLOB = "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391";
 var SCHEMA_VERSION = 1;
 var DEBUG = !!process.env.AGENTNOTE_DEBUG;
 
 // src/core/record.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { readdir, readFile as readFile3 } from "node:fs/promises";
+import { readdir, readFile as readFile3, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
 // src/agents/claude-code.ts
@@ -44,6 +50,10 @@ var HOOKS_CONFIG = {
   Stop: [{ hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }],
   UserPromptSubmit: [{ hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }],
   PreToolUse: [
+    {
+      matcher: "Edit|Write|NotebookEdit",
+      hooks: [{ type: "command", command: HOOK_COMMAND }]
+    },
     {
       matcher: "Bash",
       hooks: [{ type: "command", if: "Bash(*git commit*)", command: HOOK_COMMAND }]
@@ -147,8 +157,19 @@ var claudeCode = {
       case "UserPromptSubmit":
         return e.prompt ? { kind: "prompt", sessionId: sid, timestamp: ts, prompt: e.prompt } : null;
       case "PreToolUse": {
+        const tool = e.tool_name;
         const cmd = e.tool_input?.command ?? "";
-        if (e.tool_name === "Bash" && isGitCommit(cmd)) {
+        if ((tool === "Edit" || tool === "Write" || tool === "NotebookEdit") && e.tool_input?.file_path) {
+          return {
+            kind: "pre_edit",
+            sessionId: sid,
+            timestamp: ts,
+            tool,
+            file: e.tool_input.file_path,
+            toolUseId: e.tool_use_id
+          };
+        }
+        if (tool === "Bash" && isGitCommit(cmd)) {
           return { kind: "pre_commit", sessionId: sid, timestamp: ts, commitCommand: cmd };
         }
         return null;
@@ -161,7 +182,8 @@ var claudeCode = {
             sessionId: sid,
             timestamp: ts,
             tool,
-            file: e.tool_input.file_path
+            file: e.tool_input.file_path,
+            toolUseId: e.tool_use_id
           };
         }
         if (tool === "Bash" && isGitCommit(e.tool_input?.command ?? "")) {
@@ -260,15 +282,97 @@ async function repoRoot() {
   return git(["rev-parse", "--show-toplevel"]);
 }
 
+// src/core/attribution.ts
+function parseUnifiedHunks(diffOutput) {
+  const hunks = [];
+  for (const line of diffOutput.split("\n")) {
+    const m = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+    if (m) {
+      hunks.push({
+        oldStart: Number(m[1]),
+        oldCount: m[2] != null ? Number(m[2]) : 1,
+        newStart: Number(m[3]),
+        newCount: m[4] != null ? Number(m[4]) : 1
+      });
+    }
+  }
+  return hunks;
+}
+function expandNewPositions(hunks) {
+  const positions = /* @__PURE__ */ new Set();
+  for (const h of hunks) {
+    for (let i = 0; i < h.newCount; i++) {
+      positions.add(h.newStart + i);
+    }
+  }
+  return positions;
+}
+function countLines(hunks) {
+  let added = 0;
+  let deleted = 0;
+  for (const h of hunks) {
+    added += h.newCount;
+    deleted += h.oldCount;
+  }
+  return { added, deleted };
+}
+async function computePositionAttribution(parentBlob, committedBlob, turnPairs) {
+  const diff1Output = await gitDiffUnified0(parentBlob, committedBlob);
+  const diff1Hunks = parseUnifiedHunks(diff1Output);
+  const diff1Added = expandNewPositions(diff1Hunks);
+  const { added: totalAddedLines, deleted: deletedLines } = countLines(diff1Hunks);
+  if (turnPairs.length === 0 || totalAddedLines === 0) {
+    return {
+      aiAddedLines: 0,
+      humanAddedLines: totalAddedLines,
+      totalAddedLines,
+      deletedLines
+    };
+  }
+  const aiPositions = /* @__PURE__ */ new Set();
+  for (const { preBlob, postBlob } of turnPairs) {
+    const diff2Output = await gitDiffUnified0(preBlob, committedBlob);
+    const diff2Positions = expandNewPositions(parseUnifiedHunks(diff2Output));
+    const diff3Output = await gitDiffUnified0(postBlob, committedBlob);
+    const diff3Positions = expandNewPositions(parseUnifiedHunks(diff3Output));
+    for (const pos of diff2Positions) {
+      if (!diff3Positions.has(pos)) {
+        aiPositions.add(pos);
+      }
+    }
+  }
+  let aiAddedLines = 0;
+  let humanAddedLines = 0;
+  for (const pos of diff1Added) {
+    if (aiPositions.has(pos)) {
+      aiAddedLines++;
+    } else {
+      humanAddedLines++;
+    }
+  }
+  return { aiAddedLines, humanAddedLines, totalAddedLines, deletedLines };
+}
+async function gitDiffUnified0(blobA, blobB) {
+  if (!blobA || !blobB || blobA === blobB) return "";
+  const { stdout, exitCode } = await gitSafe(["diff", "--unified=0", "--no-color", blobA, blobB]);
+  if (exitCode !== 0 && exitCode !== 1) {
+    throw new Error(`git diff failed with exit code ${exitCode}`);
+  }
+  return stdout;
+}
+
 // src/core/entry.ts
-function calcAiRatio(commitFiles, aiFiles) {
+function calcAiRatio(commitFiles, aiFiles, lineCounts) {
+  if (lineCounts && lineCounts.totalAddedLines > 0) {
+    return Math.round(lineCounts.aiAddedLines / lineCounts.totalAddedLines * 100);
+  }
   if (commitFiles.length === 0) return 0;
   const aiSet = new Set(aiFiles);
   const matched = commitFiles.filter((f) => aiSet.has(f));
   return Math.round(matched.length / commitFiles.length * 100);
 }
 function buildEntry(opts) {
-  return {
+  const entry = {
     v: SCHEMA_VERSION,
     session_id: opts.sessionId,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -281,8 +385,14 @@ function buildEntry(opts) {
     }),
     files_in_commit: opts.commitFiles,
     files_by_ai: opts.aiFiles,
-    ai_ratio: calcAiRatio(opts.commitFiles, opts.aiFiles)
+    ai_ratio: calcAiRatio(opts.commitFiles, opts.aiFiles, opts.lineCounts)
   };
+  if (opts.lineCounts) {
+    entry.ai_added_lines = opts.lineCounts.aiAddedLines;
+    entry.total_added_lines = opts.lineCounts.totalAddedLines;
+    entry.deleted_lines = opts.lineCounts.deletedLines;
+  }
+  return entry;
 }
 
 // src/core/jsonl.ts
@@ -332,25 +442,53 @@ async function recordCommitEntry(opts) {
   } catch {
   }
   const commitFileSet = new Set(commitFiles);
-  const changeEntries = await readAllSessionJsonl(sessionDir, CHANGES_FILE);
+  const allChangeEntries = await readAllSessionJsonl(sessionDir, CHANGES_FILE);
   const promptEntries = await readAllSessionJsonl(sessionDir, PROMPTS_FILE);
+  const allPreBlobEntries = await readAllSessionJsonl(sessionDir, PRE_BLOBS_FILE);
+  const preBlobTurnById = /* @__PURE__ */ new Map();
+  for (const e of allPreBlobEntries) {
+    const id = e.tool_use_id;
+    if (id && typeof e.turn === "number") preBlobTurnById.set(id, e.turn);
+  }
+  for (const entry2 of allChangeEntries) {
+    const id = entry2.tool_use_id;
+    if (id && preBlobTurnById.has(id)) {
+      entry2.turn = preBlobTurnById.get(id);
+    }
+  }
+  const consumedPairs = await readConsumedPairs(sessionDir);
+  const changeEntries = allChangeEntries.filter((e) => !consumedPairs.has(consumedKey(e)));
+  const preBlobEntriesForTurnFix = allPreBlobEntries.filter(
+    (e) => !consumedPairs.has(consumedKey(e))
+  );
   const hasTurnData = promptEntries.some((e) => typeof e.turn === "number" && e.turn > 0);
   let aiFiles;
   let prompts;
   let relevantPromptEntries;
+  const relevantTurns = /* @__PURE__ */ new Set();
   if (hasTurnData) {
-    aiFiles = [
-      ...new Set(
-        changeEntries.map((e) => e.file).filter((f) => f && commitFileSet.has(f))
-      )
-    ];
-    const relevantTurns = /* @__PURE__ */ new Set();
+    const aiFileSet = /* @__PURE__ */ new Set();
+    for (const e of changeEntries) {
+      const f = e.file;
+      if (f && commitFileSet.has(f)) aiFileSet.add(f);
+    }
+    for (const e of preBlobEntriesForTurnFix) {
+      const f = e.file;
+      if (f && commitFileSet.has(f)) aiFileSet.add(f);
+    }
+    aiFiles = [...aiFileSet];
     for (const entry2 of changeEntries) {
       const file = entry2.file;
       if (file && commitFileSet.has(file)) {
         relevantTurns.add(typeof entry2.turn === "number" ? entry2.turn : 0);
       }
     }
+    for (const entry2 of preBlobEntriesForTurnFix) {
+      const file = entry2.file;
+      if (file && commitFileSet.has(file)) {
+        relevantTurns.add(typeof entry2.turn === "number" ? entry2.turn : 0);
+      }
+    }
     relevantPromptEntries = promptEntries.filter((e) => {
       const turn = typeof e.turn === "number" ? e.turn : 0;
       return relevantTurns.has(turn);
@@ -362,8 +500,18 @@ async function recordCommitEntry(opts) {
     relevantPromptEntries = promptEntries;
   }
   const transcriptPath = opts.transcriptPath ?? await readSavedTranscriptPath(sessionDir);
+  let crossTurnCommit = false;
+  if (hasTurnData && relevantTurns.size > 0) {
+    const turnFilePath = join2(sessionDir, TURN_FILE);
+    let currentTurn = 0;
+    if (existsSync3(turnFilePath)) {
+      currentTurn = Number.parseInt((await readFile3(turnFilePath, "utf-8")).trim(), 10) || 0;
+    }
+    const minRelevantTurn = Math.min(...relevantTurns);
+    crossTurnCommit = minRelevantTurn < currentTurn;
+  }
   let interactions;
-  if (transcriptPath && prompts.length > 0) {
+  if (transcriptPath && prompts.length > 0 && !crossTurnCommit) {
     const allInteractions = await claudeCode.extractInteractions(transcriptPath);
     interactions = allInteractions.length > 0 ? allInteractions.slice(-prompts.length) : prompts.map((p) => ({ prompt: p, response: null }));
   } else {
@@ -372,13 +520,23 @@ async function recordCommitEntry(opts) {
   if (hasTurnData) {
     attachFilesTouched(changeEntries, relevantPromptEntries, interactions, commitFileSet);
   }
+  const lineCounts = await computeLineAttribution({
+    sessionDir,
+    commitFileSet,
+    aiFileSet: new Set(aiFiles),
+    relevantTurns,
+    hasTurnData,
+    changeEntries
+  });
   const entry = buildEntry({
     sessionId: opts.sessionId,
     interactions,
     commitFiles,
-    aiFiles
+    aiFiles,
+    lineCounts: lineCounts ?? void 0
   });
   await writeNote(commitSha, entry);
+  await recordConsumedPairs(sessionDir, changeEntries, commitFileSet);
   return { promptCount: interactions.length, aiRatio: entry.ai_ratio };
 }
 function attachFilesTouched(changeEntries, promptEntries, interactions, commitFileSet) {
@@ -403,7 +561,17 @@ function attachFilesTouched(changeEntries, promptEntries, interactions, commitFi
 async function readAllSessionJsonl(sessionDir, baseFile) {
   const stem = baseFile.slice(0, baseFile.lastIndexOf(".jsonl"));
   const files = await readdir(sessionDir).catch(() => []);
-  const matching = files.filter((f) => f === baseFile || f.startsWith(`${stem}-`) && f.endsWith(".jsonl")).sort().map((f) => join2(sessionDir, f));
+  const matching = files.filter((f) => {
+    if (f === baseFile) return true;
+    const suffix = f.slice(stem.length + 1, -".jsonl".length);
+    return f.startsWith(`${stem}-`) && f.endsWith(".jsonl") && ARCHIVE_ID_RE.test(suffix);
+  }).sort((a, b) => {
+    const getId = (f) => {
+      const s = f.slice(stem.length + 1, -".jsonl".length);
+      return s ? parseInt(s, 36) : Infinity;
+    };
+    return getId(a) - getId(b);
+  }).map((f) => join2(sessionDir, f));
   const all = [];
   for (const file of matching) {
     const entries = await readJsonlEntries(file);
@@ -417,6 +585,168 @@ async function readSavedTranscriptPath(sessionDir) {
   const p = (await readFile3(saved, "utf-8")).trim();
   return p || null;
 }
+async function computeLineAttribution(opts) {
+  const { sessionDir, commitFileSet, aiFileSet, relevantTurns, hasTurnData, changeEntries } = opts;
+  let diffTreeOutput;
+  try {
+    diffTreeOutput = await git(["diff-tree", "--raw", "--root", "-r", "HEAD"]);
+  } catch {
+    return null;
+  }
+  const committedBlobs = parseDiffTreeBlobs(diffTreeOutput);
+  if (committedBlobs.size === 0) return null;
+  await ensureEmptyBlobInStore();
+  const preBlobEntries = await readAllSessionJsonl(sessionDir, PRE_BLOBS_FILE);
+  const hasPreBlobData = preBlobEntries.some((e) => e.blob);
+  const hasPostBlobData = changeEntries.some((e) => e.blob);
+  if (!hasPreBlobData && !hasPostBlobData) return null;
+  const preBlobById = /* @__PURE__ */ new Map();
+  const preBlobsFallback = /* @__PURE__ */ new Map();
+  for (const entry of preBlobEntries) {
+    const file = entry.file;
+    const turn = typeof entry.turn === "number" ? entry.turn : 0;
+    const id = entry.tool_use_id;
+    if (!file || !commitFileSet.has(file)) continue;
+    if (hasTurnData && !relevantTurns.has(turn)) continue;
+    if (id) {
+      preBlobById.set(id, { file, blob: entry.blob || "", turn });
+    } else {
+      if (!preBlobsFallback.has(file)) preBlobsFallback.set(file, []);
+      preBlobsFallback.get(file)?.push(entry.blob || "");
+    }
+  }
+  const turnPairsByFile = /* @__PURE__ */ new Map();
+  const hadNewFileEditByFile = /* @__PURE__ */ new Map();
+  const postBlobsFallback = /* @__PURE__ */ new Map();
+  for (const entry of changeEntries) {
+    const file = entry.file;
+    const turn = typeof entry.turn === "number" ? entry.turn : 0;
+    const id = entry.tool_use_id;
+    const postBlob = entry.blob || "";
+    if (!file || !commitFileSet.has(file) || !postBlob) continue;
+    if (id) {
+      const pre = preBlobById.get(id);
+      if (!pre) continue;
+      if (hasTurnData && !relevantTurns.has(pre.turn)) continue;
+      if (!pre.blob) {
+        hadNewFileEditByFile.set(file, true);
+      } else {
+        if (!turnPairsByFile.has(file)) turnPairsByFile.set(file, []);
+        turnPairsByFile.get(file)?.push({ preBlob: pre.blob, postBlob });
+      }
+    } else {
+      if (hasTurnData && !relevantTurns.has(turn)) continue;
+      if (!postBlobsFallback.has(file)) postBlobsFallback.set(file, []);
+      postBlobsFallback.get(file)?.push(postBlob);
+    }
+  }
+  for (const [file, postBlobs] of postBlobsFallback) {
+    const preBlobs = preBlobsFallback.get(file) ?? [];
+    const pairCount = Math.min(preBlobs.length, postBlobs.length);
+    for (let i = 0; i < pairCount; i++) {
+      const pre = preBlobs[i] || "";
+      const post = postBlobs[i] || "";
+      if (!pre) {
+        hadNewFileEditByFile.set(file, true);
+      } else if (post) {
+        if (!turnPairsByFile.has(file)) turnPairsByFile.set(file, []);
+        turnPairsByFile.get(file)?.push({ preBlob: pre, postBlob: post });
+      }
+    }
+  }
+  for (const file of aiFileSet) {
+    if (!commitFileSet.has(file)) continue;
+    const hasPairs = (turnPairsByFile.get(file) ?? []).length > 0;
+    const hasNewFileEdit = hadNewFileEditByFile.get(file) ?? false;
+    if (!hasPairs && !hasNewFileEdit) {
+      return null;
+    }
+  }
+  let totalAiAdded = 0;
+  let totalAdded = 0;
+  let totalDeleted = 0;
+  for (const file of commitFileSet) {
+    const blobs = committedBlobs.get(file);
+    if (!blobs) continue;
+    const { parentBlob, committedBlob } = blobs;
+    const turnPairs = turnPairsByFile.get(file) ?? [];
+    const hadNewFileEdit = hadNewFileEditByFile.get(file) ?? false;
+    try {
+      const result = await computePositionAttribution(parentBlob, committedBlob, turnPairs);
+      if (hadNewFileEdit && aiFileSet.has(file) && turnPairs.length === 0) {
+        totalAiAdded += result.totalAddedLines;
+      } else {
+        totalAiAdded += result.aiAddedLines;
+      }
+      totalAdded += result.totalAddedLines;
+      totalDeleted += result.deletedLines;
+    } catch {
+    }
+  }
+  return { aiAddedLines: totalAiAdded, totalAddedLines: totalAdded, deletedLines: totalDeleted };
+}
+function parseDiffTreeBlobs(output) {
+  const map = /* @__PURE__ */ new Map();
+  const ZEROS = "0000000000000000000000000000000000000000";
+  for (const line of output.split("\n")) {
+    const m = line.match(/^:\d+ \d+ ([0-9a-f]+) ([0-9a-f]+) \w+\t(.+)$/);
+    if (!m) continue;
+    const parentBlob = m[1] === ZEROS ? EMPTY_BLOB : m[1];
+    const committedBlob = m[2] === ZEROS ? EMPTY_BLOB : m[2];
+    const paths = m[3];
+    const parts = paths.split("	");
+    const file = parts[parts.length - 1];
+    map.set(file, { parentBlob, committedBlob });
+  }
+  return map;
+}
+async function readConsumedPairs(sessionDir) {
+  const file = join2(sessionDir, COMMITTED_PAIRS_FILE);
+  if (!existsSync3(file)) return /* @__PURE__ */ new Set();
+  const entries = await readJsonlEntries(file);
+  const set = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.tool_use_id) {
+      set.add(`id:${e.tool_use_id}`);
+    } else if (e.turn !== void 0 && e.file) {
+      set.add(`${e.turn}:${e.file}`);
+    }
+  }
+  return set;
+}
+function consumedKey(entry) {
+  if (entry.tool_use_id) return `id:${entry.tool_use_id}`;
+  return `${entry.turn}:${entry.file}`;
+}
+async function recordConsumedPairs(sessionDir, changeEntries, commitFileSet) {
+  const seen = /* @__PURE__ */ new Set();
+  const pairsFile = join2(sessionDir, COMMITTED_PAIRS_FILE);
+  for (const entry of changeEntries) {
+    const file = entry.file;
+    if (!file || !commitFileSet.has(file)) continue;
+    const key = consumedKey(entry);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    await appendJsonl(pairsFile, {
+      turn: entry.turn,
+      file,
+      tool_use_id: entry.tool_use_id ?? null
+    });
+  }
+}
+async function ensureEmptyBlobInStore() {
+  const tmp = join2(tmpdir(), `agentnote-empty-${process.pid}.tmp`);
+  try {
+    await writeFile2(tmp, "");
+    await git(["hash-object", "-w", tmp]);
+  } catch {
+  } finally {
+    try {
+      await unlink(tmp);
+    } catch {
+    }
+  }
+}
 
 // src/paths.ts
 import { join as join3 } from "node:path";
@@ -484,34 +814,48 @@ async function commit(args2) {
 
 // src/commands/hook.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile5, realpath, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile5, realpath, writeFile as writeFile3 } from "node:fs/promises";
 import { isAbsolute, join as join5, relative } from "node:path";
 
 // src/core/rotate.ts
 import { existsSync as existsSync5 } from "node:fs";
-import { readdir as readdir2, rename, unlink } from "node:fs/promises";
+import { rename } from "node:fs/promises";
 import { join as join4 } from "node:path";
-async function rotateLogs(sessionDir, commitSha, fileNames = [PROMPTS_FILE, CHANGES_FILE]) {
-  await purgeRotatedArchives(sessionDir, fileNames);
+async function rotateLogs(sessionDir, rotateId, fileNames = [PROMPTS_FILE, CHANGES_FILE]) {
   for (const name of fileNames) {
     const src = join4(sessionDir, name);
     if (existsSync5(src)) {
       const base = name.replace(".jsonl", "");
-      await rename(src, join4(sessionDir, `${base}-${commitSha.slice(0, 8)}.jsonl`));
+      await rename(src, join4(sessionDir, `${base}-${rotateId}.jsonl`));
     }
   }
 }
-async function purgeRotatedArchives(sessionDir, fileNames) {
-  const files = await readdir2(sessionDir).catch(() => []);
-  for (const name of fileNames) {
-    const stem = name.replace(".jsonl", "");
-    const rotated = files.filter((f) => f.startsWith(`${stem}-`) && f.endsWith(".jsonl"));
-    await Promise.all(rotated.map((f) => unlink(join4(sessionDir, f)).catch(() => {
-    })));
-  }
-}
 
 // src/commands/hook.ts
+async function normalizeToRepoRelative(filePath) {
+  if (!isAbsolute(filePath)) return filePath;
+  try {
+    const rawRoot = (await git(["rev-parse", "--show-toplevel"])).trim();
+    const repoRoot2 = await realpath(rawRoot);
+    let normalized = filePath;
+    if (repoRoot2.startsWith("/private") && !normalized.startsWith("/private")) {
+      normalized = `/private${normalized}`;
+    } else if (!repoRoot2.startsWith("/private") && normalized.startsWith("/private")) {
+      normalized = normalized.replace(/^\/private/, "");
+    }
+    return relative(repoRoot2, normalized);
+  } catch {
+    return filePath;
+  }
+}
+async function blobHash(absPath) {
+  try {
+    if (!existsSync6(absPath)) return EMPTY_BLOB;
+    return (await git(["hash-object", "-w", absPath])).trim();
+  } catch {
+    return EMPTY_BLOB;
+  }
+}
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -537,9 +881,9 @@ async function hook() {
   await mkdir2(sessionDir, { recursive: true });
   switch (event.kind) {
     case "session_start": {
-      await writeFile2(join5(agentnoteDirPath, SESSION_FILE), event.sessionId);
+      await writeFile3(join5(agentnoteDirPath, SESSION_FILE), event.sessionId);
       if (event.transcriptPath) {
-        await writeFile2(join5(sessionDir, TRANSCRIPT_PATH_FILE), event.transcriptPath);
+        await writeFile3(join5(sessionDir, TRANSCRIPT_PATH_FILE), event.transcriptPath);
       }
       await appendJsonl(join5(sessionDir, EVENTS_FILE), {
         event: "session_start",
@@ -547,12 +891,13 @@ async function hook() {
         timestamp: event.timestamp,
         model: event.model ?? null
       });
+      await writeFile3(join5(sessionDir, HEARTBEAT_FILE), String(Date.now()));
       break;
     }
     case "stop": {
-      await writeFile2(join5(agentnoteDirPath, SESSION_FILE), event.sessionId);
+      await writeFile3(join5(agentnoteDirPath, SESSION_FILE), event.sessionId);
       if (event.transcriptPath) {
-        await writeFile2(join5(sessionDir, TRANSCRIPT_PATH_FILE), event.transcriptPath);
+        await writeFile3(join5(sessionDir, TRANSCRIPT_PATH_FILE), event.transcriptPath);
       }
       await appendJsonl(join5(sessionDir, EVENTS_FILE), {
         event: "stop",
@@ -563,7 +908,7 @@ async function hook() {
     }
     case "prompt": {
       const rotateId = Date.now().toString(36);
-      await rotateLogs(sessionDir, rotateId);
+      await rotateLogs(sessionDir, rotateId, [PROMPTS_FILE, CHANGES_FILE, PRE_BLOBS_FILE]);
       const turnPath = join5(sessionDir, TURN_FILE);
       let turn = 0;
       if (existsSync6(turnPath)) {
@@ -571,44 +916,58 @@ async function hook() {
         turn = Number.parseInt(raw2, 10) || 0;
       }
       turn += 1;
-      await writeFile2(turnPath, String(turn));
+      await writeFile3(turnPath, String(turn));
       await appendJsonl(join5(sessionDir, PROMPTS_FILE), {
         event: "prompt",
         timestamp: event.timestamp,
         prompt: event.prompt,
         turn
       });
+      await writeFile3(join5(sessionDir, HEARTBEAT_FILE), String(Date.now()));
       break;
     }
-    case "file_change": {
-      let filePath = event.file ?? "";
-      if (isAbsolute(filePath)) {
-        try {
-          const rawRoot = (await git(["rev-parse", "--show-toplevel"])).trim();
-          const repoRoot2 = await realpath(rawRoot);
-          let normalizedFile = filePath;
-          if (repoRoot2.startsWith("/private") && !normalizedFile.startsWith("/private")) {
-            normalizedFile = `/private${normalizedFile}`;
-          } else if (!repoRoot2.startsWith("/private") && normalizedFile.startsWith("/private")) {
-            normalizedFile = normalizedFile.replace(/^\/private/, "");
-          }
-          filePath = relative(repoRoot2, normalizedFile);
-        } catch {
-        }
+    case "pre_edit": {
+      const absPath = event.file ?? "";
+      const filePath = await normalizeToRepoRelative(absPath);
+      let turn = 0;
+      const turnPath = join5(sessionDir, TURN_FILE);
+      if (existsSync6(turnPath)) {
+        const raw2 = (await readFile5(turnPath, "utf-8")).trim();
+        turn = Number.parseInt(raw2, 10) || 0;
       }
+      const preBlob = isAbsolute(absPath) ? await blobHash(absPath) : EMPTY_BLOB;
+      await appendJsonl(join5(sessionDir, PRE_BLOBS_FILE), {
+        event: "pre_blob",
+        turn,
+        file: filePath,
+        blob: preBlob,
+        // tool_use_id links this pre-blob to its PostToolUse counterpart,
+        // enabling correct pairing even when async hooks fire out of order.
+        tool_use_id: event.toolUseId ?? null
+      });
+      break;
+    }
+    case "file_change": {
+      const absPath = event.file ?? "";
+      const filePath = await normalizeToRepoRelative(absPath);
       let turn = 0;
       const turnPath = join5(sessionDir, TURN_FILE);
       if (existsSync6(turnPath)) {
         const raw2 = (await readFile5(turnPath, "utf-8")).trim();
         turn = Number.parseInt(raw2, 10) || 0;
       }
+      const postBlob = isAbsolute(absPath) ? await blobHash(absPath) : EMPTY_BLOB;
       await appendJsonl(join5(sessionDir, CHANGES_FILE), {
         event: "file_change",
         timestamp: event.timestamp,
         tool: event.tool,
         file: filePath,
         session_id: event.sessionId,
-        turn
+        turn,
+        blob: postBlob,
+        // Same tool_use_id as the matching pre_blob entry — used for reliable pairing
+        // even when this async hook fires after the next prompt has advanced the turn counter.
+        tool_use_id: event.toolUseId ?? null
       });
       break;
     }
@@ -644,7 +1003,7 @@ async function hook() {
 
 // src/commands/init.ts
 import { existsSync as existsSync7 } from "node:fs";
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile4 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 var WORKFLOW_TEMPLATE = `name: Agent Note
 on:
@@ -691,7 +1050,7 @@ async function init(args2) {
       results.push("  \xB7 workflow already exists at .github/workflows/agentnote.yml");
     } else {
       await mkdir3(workflowDir, { recursive: true });
-      await writeFile3(workflowPath, WORKFLOW_TEMPLATE);
+      await writeFile4(workflowPath, WORKFLOW_TEMPLATE);
       results.push("  \u2713 workflow created at .github/workflows/agentnote.yml");
     }
   }
@@ -790,7 +1149,9 @@ async function collectReport(base) {
         files_total: 0,
         files_ai: 0,
         files: [],
-        interactions: []
+        interactions: [],
+        ai_added_lines: null,
+        total_added_lines: null
       });
       continue;
     }
@@ -811,12 +1172,23 @@ async function collectReport(base) {
         path: f,
         by_ai: filesByAi.includes(f)
       })),
-      interactions
+      interactions,
+      ai_added_lines: entry.ai_added_lines ?? null,
+      total_added_lines: entry.total_added_lines ?? null
     });
   }
   const tracked = commits.filter((c) => c.session_id !== null);
   const totalFiles = tracked.reduce((s, c) => s + c.files_total, 0);
   const totalFilesAi = tracked.reduce((s, c) => s + c.files_ai, 0);
+  const allHaveLineData = tracked.every((c) => c.total_added_lines !== null);
+  let overallAiRatio;
+  if (allHaveLineData) {
+    const totalAiLines = tracked.reduce((s, c) => s + (c.ai_added_lines ?? 0), 0);
+    const totalAllLines = tracked.reduce((s, c) => s + (c.total_added_lines ?? 0), 0);
+    overallAiRatio = totalAllLines > 0 ? Math.round(totalAiLines / totalAllLines * 100) : 0;
+  } else {
+    overallAiRatio = totalFiles > 0 ? Math.round(totalFilesAi / totalFiles * 100) : 0;
+  }
   return {
     base,
     head,
@@ -825,7 +1197,7 @@ async function collectReport(base) {
     total_prompts: tracked.reduce((s, c) => s + c.prompts_count, 0),
     total_files: totalFiles,
     total_files_ai: totalFilesAi,
-    overall_ai_ratio: totalFiles > 0 ? Math.round(totalFilesAi / totalFiles * 100) : 0,
+    overall_ai_ratio: overallAiRatio,
     commits
   };
 }
@@ -1082,6 +1454,8 @@ async function session(sessionId) {
   console.log(`Commits: ${matches.length}`);
   console.log();
   let totalPrompts = 0;
+  let totalAiLines = 0;
+  let totalAllLines = 0;
   let totalRatio = 0;
   let ratioCount = 0;
   for (const m of matches) {
@@ -1089,16 +1463,22 @@ async function session(sessionId) {
     if (m.entry) {
       const promptCount = m.entry.interactions?.length ?? m.entry.prompts?.length ?? 0;
       totalPrompts += promptCount;
-      totalRatio += m.entry.ai_ratio;
-      ratioCount++;
+      if (m.entry.ai_added_lines !== void 0 && m.entry.total_added_lines !== void 0) {
+        totalAiLines += m.entry.ai_added_lines;
+        totalAllLines += m.entry.total_added_lines;
+      } else {
+        totalRatio += m.entry.ai_ratio;
+        ratioCount++;
+      }
       suffix = `  [\u{1F916}${m.entry.ai_ratio}% | ${promptCount}p]`;
     }
     console.log(`${m.shortInfo}${suffix}`);
   }
   console.log();
-  if (ratioCount > 0) {
-    const avgRatio = Math.round(totalRatio / ratioCount);
-    console.log(`Total: ${totalPrompts} prompts, avg AI ratio ${avgRatio}%`);
+  const displayRatio = totalAllLines > 0 ? Math.round(totalAiLines / totalAllLines * 100) : ratioCount > 0 ? Math.round(totalRatio / ratioCount) : null;
+  if (displayRatio !== null) {
+    const lineDetail = totalAllLines > 0 ? ` (${totalAiLines}/${totalAllLines} lines)` : "";
+    console.log(`Total: ${totalPrompts} prompts, AI ratio ${displayRatio}%${lineDetail}`);
   }
 }
 
@@ -1120,7 +1500,8 @@ async function show(commitRef) {
   if (entry) {
     console.log();
     const ratioBar = renderRatioBar(entry.ai_ratio);
-    console.log(`ai:      ${entry.ai_ratio}% ${ratioBar}`);
+    const lineDetail = entry.ai_added_lines !== void 0 && entry.total_added_lines !== void 0 && entry.total_added_lines > 0 ? ` (${entry.ai_added_lines}/${entry.total_added_lines} lines)` : "";
+    console.log(`ai:      ${entry.ai_ratio}%${lineDetail} ${ratioBar}`);
     console.log(
       `files:   ${entry.files_in_commit.length} changed, ${entry.files_by_ai.length} by AI`
     );
@@ -1181,7 +1562,7 @@ function truncateLines(text, maxLen) {
 // src/commands/status.ts
 import { existsSync as existsSync8 } from "node:fs";
 import { readFile as readFile6 } from "node:fs/promises";
-var VERSION = "0.1.6";
+var VERSION = "0.1.7";
 async function status() {
   console.log(`agentnote v${VERSION}`);
   console.log();
@@ -1210,7 +1591,7 @@ async function status() {
 }
 
 // src/cli.ts
-var VERSION2 = "0.1.6";
+var VERSION2 = "0.1.7";
 var HELP = `
 agentnote v${VERSION2} \u2014 remember why your code changed
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wasabeef/agentnote",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Remember why your code changed. Link AI agent sessions to git commits.",
   "type": "module",
   "bin": {