@wasabeef/agentnote 0.1.5 → 0.1.7

package/dist/cli.js

@@ -1,83 +1,59 @@
 #!/usr/bin/env node
 
-// src/commands/init.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join3 } from "node:path";
-
-// src/paths.ts
-import { join } from "node:path";
+// src/commands/commit.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
 
-// src/git.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
-async function git(args2, options) {
-  const { stdout } = await execFileAsync("git", args2, {
-    cwd: options?.cwd,
-    encoding: "utf-8"
-  });
-  return stdout.trim();
-}
-async function gitSafe(args2, options) {
-  try {
-    const stdout = await git(args2, options);
-    return { stdout, exitCode: 0 };
-  } catch (err) {
-    return { stdout: err.stdout?.trim() ?? "", exitCode: err.code ?? 1 };
-  }
-}
-async function repoRoot() {
-  return git(["rev-parse", "--show-toplevel"]);
-}
+// src/core/constants.ts
+var TRAILER_KEY = "Agentnote-Session";
+var NOTES_REF = "agentnote";
+var NOTES_REF_FULL = `refs/notes/${NOTES_REF}`;
+var NOTES_FETCH_REFSPEC = `+${NOTES_REF_FULL}:${NOTES_REF_FULL}`;
+var AGENTNOTE_DIR = "agentnote";
+var SESSIONS_DIR = "sessions";
+var PROMPTS_FILE = "prompts.jsonl";
+var CHANGES_FILE = "changes.jsonl";
+var EVENTS_FILE = "events.jsonl";
+var TRANSCRIPT_PATH_FILE = "transcript_path";
+var TURN_FILE = "turn";
+var SESSION_FILE = "session";
+var MAX_COMMITS = 500;
+var BAR_WIDTH_COMPACT = 5;
+var BAR_WIDTH_FULL = 20;
+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/paths.ts
-var _root = null;
-var _gitDir = null;
-async function root() {
-  if (!_root) {
-    try {
-      _root = await repoRoot();
-    } catch {
-      console.error("error: git repository not found");
-      process.exit(1);
-    }
-  }
-  return _root;
-}
-async function gitDir() {
-  if (!_gitDir) {
-    _gitDir = await git(["rev-parse", "--git-dir"]);
-    if (!_gitDir.startsWith("/")) {
-      _gitDir = join(await root(), _gitDir);
-    }
-  }
-  return _gitDir;
-}
-async function agentnoteDir() {
-  return join(await gitDir(), "agentnote");
-}
-async function sessionFile() {
-  return join(await agentnoteDir(), "session");
-}
+// src/core/record.ts
+import { existsSync as existsSync3 } from "node:fs";
+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
-import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { existsSync, readdirSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
+import { join } from "node:path";
 var HOOK_COMMAND = "npx --yes @wasabeef/agentnote hook";
 var HOOKS_CONFIG = {
-  SessionStart: [
-    { hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }
-  ],
-  Stop: [
-    { hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }
-  ],
-  UserPromptSubmit: [
-    { hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }
-  ],
+  SessionStart: [{ hooks: [{ type: "command", command: HOOK_COMMAND, async: true }] }],
+  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 }]
@@ -95,18 +71,17 @@ function isValidSessionId(id) {
   return UUID_PATTERN.test(id);
 }
 function isValidTranscriptPath(p) {
-  const claudeBase = join2(homedir(), ".claude");
+  const claudeBase = join(homedir(), ".claude");
   return p.startsWith(claudeBase);
 }
 function isGitCommit(cmd) {
-  const trimmed = cmd.trim();
-  return (trimmed.startsWith("git commit") || trimmed.startsWith("git -c ")) && trimmed.includes("commit") && !trimmed.includes("--amend");
+  return cmd.includes("git commit") && !cmd.includes("--amend");
 }
 var claudeCode = {
   name: "claude-code",
   settingsRelPath: ".claude/settings.json",
   async installHooks(repoRoot2) {
-    const settingsPath = join2(repoRoot2, this.settingsRelPath);
+    const settingsPath = join(repoRoot2, this.settingsRelPath);
     const { dirname } = await import("node:path");
     await mkdir(dirname(settingsPath), { recursive: true });
     let settings = {};
@@ -119,15 +94,17 @@ var claudeCode = {
     }
     const hooks = settings.hooks ?? {};
     const raw = JSON.stringify(hooks);
-    if (raw.includes("@wasabeef/agentnote")) return;
+    if (raw.includes("@wasabeef/agentnote") || raw.includes("agentnote hook") || raw.includes("cli.js hook"))
+      return;
     for (const [event, entries] of Object.entries(HOOKS_CONFIG)) {
       hooks[event] = [...hooks[event] ?? [], ...entries];
     }
     settings.hooks = hooks;
-    await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    await writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
   },
   async removeHooks(repoRoot2) {
-    const settingsPath = join2(repoRoot2, this.settingsRelPath);
+    const settingsPath = join(repoRoot2, this.settingsRelPath);
     if (!existsSync(settingsPath)) return;
     try {
       const settings = JSON.parse(await readFile(settingsPath, "utf-8"));
@@ -135,21 +112,22 @@ var claudeCode = {
       for (const [event, entries] of Object.entries(settings.hooks)) {
         settings.hooks[event] = entries.filter((e) => {
           const text = JSON.stringify(e);
-          return !text.includes("@wasabeef/agentnote");
+          return !text.includes("@wasabeef/agentnote") && !text.includes("agentnote hook") && !text.includes("cli.js hook");
         });
         if (settings.hooks[event].length === 0) delete settings.hooks[event];
       }
       if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
-      await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      await writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
     } catch {
     }
   },
   async isEnabled(repoRoot2) {
-    const settingsPath = join2(repoRoot2, this.settingsRelPath);
+    const settingsPath = join(repoRoot2, this.settingsRelPath);
     if (!existsSync(settingsPath)) return false;
     try {
       const content = await readFile(settingsPath, "utf-8");
-      return content.includes("@wasabeef/agentnote");
+      return content.includes("@wasabeef/agentnote") || content.includes("agentnote hook") || content.includes("cli.js hook");
     } catch {
       return false;
     }
@@ -167,14 +145,31 @@ var claudeCode = {
     const tp = e.transcript_path && isValidTranscriptPath(e.transcript_path) ? e.transcript_path : void 0;
     switch (e.hook_event_name) {
       case "SessionStart":
-        return { kind: "session_start", sessionId: sid, timestamp: ts, model: e.model, transcriptPath: tp };
+        return {
+          kind: "session_start",
+          sessionId: sid,
+          timestamp: ts,
+          model: e.model,
+          transcriptPath: tp
+        };
       case "Stop":
         return { kind: "stop", sessionId: sid, timestamp: ts, transcriptPath: tp };
       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;
@@ -182,7 +177,14 @@ var claudeCode = {
       case "PostToolUse": {
         const tool = e.tool_name;
         if ((tool === "Edit" || tool === "Write" || tool === "NotebookEdit") && e.tool_input?.file_path) {
-          return { kind: "file_change", sessionId: sid, timestamp: ts, tool, file: e.tool_input.file_path };
+          return {
+            kind: "file_change",
+            sessionId: sid,
+            timestamp: ts,
+            tool,
+            file: e.tool_input.file_path,
+            toolUseId: e.tool_use_id
+          };
         }
         if (tool === "Bash" && isGitCommit(e.tool_input?.command ?? "")) {
           return { kind: "post_commit", sessionId: sid, timestamp: ts, transcriptPath: tp };
@@ -195,13 +197,13 @@ var claudeCode = {
   },
   findTranscript(sessionId) {
     if (!isValidSessionId(sessionId)) return null;
-    const claudeDir = join2(homedir(), ".claude", "projects");
+    const claudeDir = join(homedir(), ".claude", "projects");
     if (!existsSync(claudeDir)) return null;
     try {
       for (const project of readdirSync(claudeDir)) {
-        const sessionsDir = join2(claudeDir, project, "sessions");
+        const sessionsDir = join(claudeDir, project, "sessions");
         if (!existsSync(sessionsDir)) continue;
-        const candidate = join2(sessionsDir, `${sessionId}.jsonl`);
+        const candidate = join(sessionsDir, `${sessionId}.jsonl`);
         if (existsSync(candidate) && isValidTranscriptPath(candidate)) {
           return candidate;
         }
@@ -253,141 +255,174 @@ var claudeCode = {
   }
 };
 
-// src/commands/init.ts
-var WORKFLOW_TEMPLATE = `name: Agent Note
-on:
-  pull_request:
-    types: [opened, synchronize]
-concurrency:
-  group: agentnote-\${{ github.event.pull_request.number }}
-  cancel-in-progress: true
-permissions:
-  contents: read
-  pull-requests: write
-jobs:
-  report:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: wasabeef/agentnote@v0
-`;
-async function init(args2) {
-  const skipHooks = args2.includes("--no-hooks");
-  const skipAction = args2.includes("--no-action");
-  const skipNotes = args2.includes("--no-notes");
-  const hooksOnly = args2.includes("--hooks");
-  const actionOnly = args2.includes("--action");
-  const repoRoot2 = await root();
-  const results = [];
-  await mkdir2(await agentnoteDir(), { recursive: true });
-  if (!skipHooks && !actionOnly) {
-    const adapter = claudeCode;
-    if (await adapter.isEnabled(repoRoot2)) {
-      results.push("  \xB7 hooks already configured");
-    } else {
-      await adapter.installHooks(repoRoot2);
-      results.push("  \u2713 hooks added to .claude/settings.json");
+// src/git.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function git(args2, options) {
+  const { stdout } = await execFileAsync("git", args2, {
+    cwd: options?.cwd,
+    encoding: "utf-8"
+  });
+  return stdout.trim();
+}
+async function gitSafe(args2, options) {
+  try {
+    const stdout = await git(args2, options);
+    return { stdout, exitCode: 0 };
+  } catch (err) {
+    const e = err;
+    return {
+      stdout: typeof e.stdout === "string" ? e.stdout.trim() : "",
+      exitCode: typeof e.code === "number" ? e.code : 1
+    };
+  }
+}
+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
+      });
     }
   }
-  if (!skipAction && !hooksOnly) {
-    const workflowDir = join3(repoRoot2, ".github", "workflows");
-    const workflowPath = join3(workflowDir, "agentnote.yml");
-    if (existsSync2(workflowPath)) {
-      results.push("  \xB7 workflow already exists at .github/workflows/agentnote.yml");
-    } else {
-      await mkdir2(workflowDir, { recursive: true });
-      await writeFile2(workflowPath, WORKFLOW_TEMPLATE);
-      results.push("  \u2713 workflow created at .github/workflows/agentnote.yml");
+  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);
     }
   }
-  if (!skipNotes && !hooksOnly && !actionOnly) {
-    const { stdout } = await gitSafe([
-      "config",
-      "--get-all",
-      "remote.origin.fetch"
-    ]);
-    if (stdout.includes("refs/notes/agentnote")) {
-      results.push("  \xB7 git already configured to fetch notes");
+  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 {
-      await gitSafe([
-        "config",
-        "--add",
-        "remote.origin.fetch",
-        "+refs/notes/agentnote:refs/notes/agentnote"
-      ]);
-      results.push("  \u2713 git configured to auto-fetch notes on pull");
+      humanAddedLines++;
     }
   }
-  console.log("");
-  console.log("agentnote init");
-  console.log("");
-  for (const line of results) {
-    console.log(line);
+  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}`);
   }
-  const toCommit = [];
-  if (!skipHooks && !actionOnly) toCommit.push(".claude/settings.json");
-  if (!skipAction && !hooksOnly) {
-    const workflowPath = join3(repoRoot2, ".github", "workflows", "agentnote.yml");
-    if (existsSync2(workflowPath)) toCommit.push(".github/workflows/agentnote.yml");
+  return stdout;
+}
+
+// src/core/entry.ts
+function calcAiRatio(commitFiles, aiFiles, lineCounts) {
+  if (lineCounts && lineCounts.totalAddedLines > 0) {
+    return Math.round(lineCounts.aiAddedLines / lineCounts.totalAddedLines * 100);
   }
-  if (toCommit.length > 0) {
-    console.log("");
-    console.log("  Next: commit and push these files");
-    console.log(`    git add ${toCommit.join(" ")}`);
-    console.log('    git commit -m "chore: enable agentnote session tracking"');
-    console.log("    git push");
+  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) {
+  const entry = {
+    v: SCHEMA_VERSION,
+    session_id: opts.sessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    interactions: opts.interactions.map((i) => {
+      const base = { prompt: i.prompt, response: i.response };
+      if (i.files_touched && i.files_touched.length > 0) {
+        base.files_touched = i.files_touched;
+      }
+      return base;
+    }),
+    files_in_commit: opts.commitFiles,
+    files_by_ai: 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;
   }
-  console.log("");
+  return entry;
 }
 
-// src/commands/commit.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { existsSync as existsSync5 } from "node:fs";
-import { spawn } from "node:child_process";
-import { join as join5 } from "node:path";
-
 // src/core/jsonl.ts
-import { readFile as readFile2, appendFile } from "node:fs/promises";
-import { existsSync as existsSync3 } from "node:fs";
-async function readJsonlField(filePath, field) {
-  if (!existsSync3(filePath)) return [];
+import { existsSync as existsSync2 } from "node:fs";
+import { appendFile, readFile as readFile2 } from "node:fs/promises";
+async function readJsonlEntries(filePath) {
+  if (!existsSync2(filePath)) return [];
   const content = await readFile2(filePath, "utf-8");
-  const seen = /* @__PURE__ */ new Set();
-  const values = [];
+  const entries = [];
   for (const line of content.trim().split("\n")) {
     if (!line) continue;
     try {
-      const entry = JSON.parse(line);
-      const val = entry[field];
-      if (val && !seen.has(val)) {
-        seen.add(val);
-        values.push(val);
-      }
+      entries.push(JSON.parse(line));
     } catch {
     }
   }
-  return values;
+  return entries;
 }
 async function appendJsonl(filePath, data) {
-  await appendFile(filePath, JSON.stringify(data) + "\n");
+  await appendFile(filePath, `${JSON.stringify(data)}
+`);
 }
 
 // src/core/storage.ts
-var NOTES_REF = "agentnote";
 async function writeNote(commitSha, data) {
   const body = JSON.stringify(data, null, 2);
   await gitSafe(["notes", `--ref=${NOTES_REF}`, "add", "-f", "-m", body, commitSha]);
 }
 async function readNote(commitSha) {
-  const { stdout, exitCode } = await gitSafe([
-    "notes",
-    `--ref=${NOTES_REF}`,
-    "show",
-    commitSha
-  ]);
+  const { stdout, exitCode } = await gitSafe(["notes", `--ref=${NOTES_REF}`, "show", commitSha]);
   if (exitCode !== 0 || !stdout.trim()) return null;
   try {
     return JSON.parse(stdout);
@@ -396,53 +431,364 @@ async function readNote(commitSha) {
   }
 }
 
-// src/core/entry.ts
-var SCHEMA_VERSION = 1;
-function calcAiRatio(commitFiles, aiFiles) {
-  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);
+// src/core/record.ts
+async function recordCommitEntry(opts) {
+  const sessionDir = join2(opts.agentnoteDirPath, "sessions", opts.sessionId);
+  const commitSha = await git(["rev-parse", "HEAD"]);
+  let commitFiles = [];
+  try {
+    const raw = await git(["diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"]);
+    commitFiles = raw.split("\n").filter(Boolean);
+  } catch {
+  }
+  const commitFileSet = new Set(commitFiles);
+  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) {
+    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);
+    });
+    prompts = relevantPromptEntries.map((e) => e.prompt);
+  } else {
+    aiFiles = changeEntries.map((e) => e.file).filter(Boolean);
+    prompts = promptEntries.map((e) => e.prompt);
+    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 && !crossTurnCommit) {
+    const allInteractions = await claudeCode.extractInteractions(transcriptPath);
+    interactions = allInteractions.length > 0 ? allInteractions.slice(-prompts.length) : prompts.map((p) => ({ prompt: p, response: null }));
+  } else {
+    interactions = prompts.map((p) => ({ prompt: p, response: null }));
+  }
+  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,
+    lineCounts: lineCounts ?? void 0
+  });
+  await writeNote(commitSha, entry);
+  await recordConsumedPairs(sessionDir, changeEntries, commitFileSet);
+  return { promptCount: interactions.length, aiRatio: entry.ai_ratio };
 }
-function buildEntry(opts) {
-  return {
-    v: SCHEMA_VERSION,
-    session_id: opts.sessionId,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    interactions: opts.interactions,
-    files_in_commit: opts.commitFiles,
-    files_by_ai: opts.aiFiles,
-    ai_ratio: calcAiRatio(opts.commitFiles, opts.aiFiles)
-  };
+function attachFilesTouched(changeEntries, promptEntries, interactions, commitFileSet) {
+  const filesByTurn = /* @__PURE__ */ new Map();
+  for (const entry of changeEntries) {
+    const turn = typeof entry.turn === "number" ? entry.turn : 0;
+    const file = entry.file;
+    if (!file || !commitFileSet.has(file)) continue;
+    if (!filesByTurn.has(turn)) filesByTurn.set(turn, /* @__PURE__ */ new Set());
+    filesByTurn.get(turn)?.add(file);
+  }
+  for (let i = 0; i < interactions.length; i++) {
+    const promptEntry = promptEntries[i];
+    if (!promptEntry) continue;
+    const turn = typeof promptEntry.turn === "number" ? promptEntry.turn : 0;
+    const files = filesByTurn.get(turn);
+    if (files && files.size > 0) {
+      interactions[i].files_touched = [...files];
+    }
+  }
+}
+async function readAllSessionJsonl(sessionDir, baseFile) {
+  const stem = baseFile.slice(0, baseFile.lastIndexOf(".jsonl"));
+  const files = await readdir(sessionDir).catch(() => []);
+  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);
+    all.push(...entries);
+  }
+  return all;
+}
+async function readSavedTranscriptPath(sessionDir) {
+  const saved = join2(sessionDir, TRANSCRIPT_PATH_FILE);
+  if (!existsSync3(saved)) return null;
+  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/core/rotate.ts
-import { rename } from "node:fs/promises";
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join4 } from "node:path";
-async function rotateLogs(sessionDir, commitSha, fileNames = ["prompts.jsonl", "changes.jsonl"]) {
-  for (const name of fileNames) {
-    const src = join4(sessionDir, name);
-    if (existsSync4(src)) {
-      const base = name.replace(".jsonl", "");
-      await rename(
-        src,
-        join4(sessionDir, `${base}-${commitSha.slice(0, 8)}.jsonl`)
-      );
+// src/paths.ts
+import { join as join3 } from "node:path";
+var _root = null;
+var _gitDir = null;
+async function root() {
+  if (!_root) {
+    try {
+      _root = await repoRoot();
+    } catch {
+      console.error("error: git repository not found");
+      process.exit(1);
     }
   }
+  return _root;
+}
+async function gitDir() {
+  if (!_gitDir) {
+    _gitDir = await git(["rev-parse", "--git-dir"]);
+    if (!_gitDir.startsWith("/")) {
+      _gitDir = join3(await root(), _gitDir);
+    }
+  }
+  return _gitDir;
+}
+async function agentnoteDir() {
+  return join3(await gitDir(), AGENTNOTE_DIR);
+}
+async function sessionFile() {
+  return join3(await agentnoteDir(), SESSION_FILE);
 }
 
 // src/commands/commit.ts
 async function commit(args2) {
   const sf = await sessionFile();
   let sessionId = "";
-  if (existsSync5(sf)) {
-    sessionId = (await readFile3(sf, "utf-8")).trim();
+  if (existsSync4(sf)) {
+    sessionId = (await readFile4(sf, "utf-8")).trim();
   }
   const gitArgs = ["commit"];
   if (sessionId) {
-    gitArgs.push("--trailer", `Agentnote-Session: ${sessionId}`);
+    gitArgs.push("--trailer", `${TRAILER_KEY}: ${sessionId}`);
   }
   gitArgs.push(...args2);
   const child = spawn("git", gitArgs, {
@@ -458,210 +804,58 @@ async function commit(args2) {
   if (sessionId) {
     try {
       const agentnoteDirPath = await agentnoteDir();
-      const sessionDir = join5(agentnoteDirPath, "sessions", sessionId);
-      const commitSha = await git(["rev-parse", "HEAD"]);
-      let commitFiles = [];
-      try {
-        const raw = await git([
-          "diff-tree",
-          "--no-commit-id",
-          "--name-only",
-          "-r",
-          "HEAD"
-        ]);
-        commitFiles = raw.split("\n").filter(Boolean);
-      } catch {
-      }
-      const aiFiles = await readJsonlField(
-        join5(sessionDir, "changes.jsonl"),
-        "file"
-      );
-      const prompts = await readJsonlField(
-        join5(sessionDir, "prompts.jsonl"),
-        "prompt"
-      );
-      let interactions;
-      const transcriptPathFile = join5(sessionDir, "transcript_path");
-      if (existsSync5(transcriptPathFile)) {
-        const transcriptPath = (await readFile3(transcriptPathFile, "utf-8")).trim();
-        if (transcriptPath) {
-          const allInteractions = await claudeCode.extractInteractions(transcriptPath);
-          interactions = prompts.length > 0 && allInteractions.length > 0 ? allInteractions.slice(-prompts.length) : prompts.map((p) => ({ prompt: p, response: null }));
-        } else {
-          interactions = prompts.map((p) => ({ prompt: p, response: null }));
-        }
-      } else {
-        interactions = prompts.map((p) => ({ prompt: p, response: null }));
-      }
-      const entry = buildEntry({
-        sessionId,
-        interactions,
-        commitFiles,
-        aiFiles
-      });
-      await writeNote(commitSha, entry);
-      await rotateLogs(sessionDir, commitSha);
-      console.log(
-        `agentnote: ${interactions.length} prompts, AI ratio ${entry.ai_ratio}%`
-      );
+      const result = await recordCommitEntry({ agentnoteDirPath, sessionId });
+      console.log(`agentnote: ${result.promptCount} prompts, AI ratio ${result.aiRatio}%`);
     } catch (err) {
       console.error(`agentnote: warning: ${err.message}`);
     }
   }
 }
 
-// src/commands/show.ts
-import { stat } from "node:fs/promises";
-async function show(commitRef) {
-  const ref = commitRef ?? "HEAD";
-  const commitInfo = await git(["log", "-1", "--format=%h %s", ref]);
-  const commitSha = await git(["log", "-1", "--format=%H", ref]);
-  const sessionId = (await git([
-    "log",
-    "-1",
-    "--format=%(trailers:key=Agentnote-Session,valueonly)",
-    ref
-  ])).trim();
-  console.log(`commit:  ${commitInfo}`);
-  if (!sessionId) {
-    console.log("session: none (no agentnote data)");
-    return;
-  }
-  console.log(`session: ${sessionId}`);
-  const raw = await readNote(commitSha);
-  const entry = raw;
-  if (entry) {
-    console.log();
-    const ratioBar = renderRatioBar(entry.ai_ratio);
-    console.log(`ai:      ${entry.ai_ratio}% ${ratioBar}`);
-    console.log(
-      `files:   ${entry.files_in_commit.length} changed, ${entry.files_by_ai.length} by AI`
-    );
-    if (entry.files_in_commit.length > 0) {
-      console.log();
-      for (const file of entry.files_in_commit) {
-        const isAi = entry.files_by_ai.includes(file);
-        const marker = isAi ? "  \u{1F916}" : "  \u{1F464}";
-        console.log(`  ${file}${marker}`);
-      }
-    }
-    const interactions = entry.interactions ?? (entry.prompts ?? []).map((p) => ({
-      prompt: p,
-      response: null
-    }));
-    if (interactions.length > 0) {
-      console.log();
-      console.log(`prompts: ${interactions.length}`);
-      for (let i = 0; i < interactions.length; i++) {
-        const { prompt, response } = interactions[i];
-        console.log();
-        console.log(`  ${i + 1}. ${truncateLines(prompt, 120)}`);
-        if (response) {
-          console.log(`     \u2192 ${truncateLines(response, 200)}`);
-        }
-      }
+// src/commands/hook.ts
+import { existsSync as existsSync6 } from "node:fs";
+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 { rename } from "node:fs/promises";
+import { join as join4 } from "node:path";
+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}-${rotateId}.jsonl`));
     }
-  } else {
-    console.log("entry:   no agentnote note found for this commit");
-  }
-  console.log();
-  const adapter = claudeCode;
-  const transcriptPath = adapter.findTranscript(sessionId);
-  if (transcriptPath) {
-    const stats = await stat(transcriptPath);
-    const sizeKb = (stats.size / 1024).toFixed(1);
-    console.log(`transcript: ${transcriptPath} (${sizeKb} KB)`);
-  } else {
-    console.log("transcript: not found locally");
   }
 }
-function renderRatioBar(ratio) {
-  const width = 20;
-  const filled = Math.round(ratio / 100 * width);
-  const empty = width - filled;
-  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
-}
-function truncateLines(text, maxLen) {
-  const firstLine = text.split("\n")[0];
-  if (firstLine.length <= maxLen) return firstLine;
-  return firstLine.slice(0, maxLen) + "\u2026";
-}
 
-// src/commands/log.ts
-async function log(count = 10) {
-  const raw = await git([
-    "log",
-    `-${count}`,
-    "--format=%H	%h %s	%(trailers:key=Agentnote-Session,valueonly)"
-  ]);
-  if (!raw) {
-    console.log("no commits found");
-    return;
-  }
-  for (const line of raw.split("\n")) {
-    if (!line.trim()) continue;
-    const parts = line.split("	");
-    const fullSha = parts[0];
-    const commitPart = parts[1];
-    const sid = parts[2]?.trim();
-    if (!fullSha || !commitPart) continue;
-    if (!sid) {
-      console.log(commitPart);
-      continue;
-    }
-    let ratioStr = "";
-    let promptCount = "";
-    const note = await readNote(fullSha);
-    if (note) {
-      const entry = note;
-      ratioStr = `${entry.ai_ratio}%`;
-      promptCount = `${entry.interactions?.length ?? entry.prompts?.length ?? 0}p`;
-    }
-    if (ratioStr) {
-      console.log(
-        `${commitPart}  [${sid.slice(0, 8)}\u2026 | \u{1F916}${ratioStr} | ${promptCount}]`
-      );
-    } else {
-      console.log(`${commitPart}  [${sid.slice(0, 8)}\u2026]`);
+// 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;
   }
 }
-
-// src/commands/status.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { existsSync as existsSync6 } from "node:fs";
-var VERSION = "0.1.0";
-async function status() {
-  console.log(`agentnote v${VERSION}`);
-  console.log();
-  const repoRoot2 = await root();
-  const adapter = claudeCode;
-  const hooksActive = await adapter.isEnabled(repoRoot2);
-  if (hooksActive) {
-    console.log("hooks:   active");
-  } else {
-    console.log("hooks:   not configured (run 'agentnote init')");
-  }
-  const sessionPath = await sessionFile();
-  if (existsSync6(sessionPath)) {
-    const sid = (await readFile4(sessionPath, "utf-8")).trim();
-    console.log(`session: ${sid.slice(0, 8)}\u2026`);
-  } else {
-    console.log("session: none");
+async function blobHash(absPath) {
+  try {
+    if (!existsSync6(absPath)) return EMPTY_BLOB;
+    return (await git(["hash-object", "-w", absPath])).trim();
+  } catch {
+    return EMPTY_BLOB;
   }
-  const { stdout } = await gitSafe([
-    "log",
-    "-20",
-    "--format=%(trailers:key=Agentnote-Session,valueonly)"
-  ]);
-  const linked = stdout.split("\n").filter((line) => line.trim().length > 0).length;
-  console.log(`linked:  ${linked}/20 recent commits`);
 }
-
-// src/commands/hook.ts
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3, realpath } from "node:fs/promises";
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join6, relative, isAbsolute } from "node:path";
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -683,28 +877,29 @@ async function hook() {
   const event = adapter.parseEvent(input);
   if (!event) return;
   const agentnoteDirPath = await agentnoteDir();
-  const sessionDir = join6(agentnoteDirPath, "sessions", event.sessionId);
-  await mkdir3(sessionDir, { recursive: true });
+  const sessionDir = join5(agentnoteDirPath, SESSIONS_DIR, event.sessionId);
+  await mkdir2(sessionDir, { recursive: true });
   switch (event.kind) {
     case "session_start": {
-      await writeFile3(join6(agentnoteDirPath, "session"), event.sessionId);
+      await writeFile3(join5(agentnoteDirPath, SESSION_FILE), event.sessionId);
       if (event.transcriptPath) {
-        await writeFile3(join6(sessionDir, "transcript_path"), event.transcriptPath);
+        await writeFile3(join5(sessionDir, TRANSCRIPT_PATH_FILE), event.transcriptPath);
       }
-      await appendJsonl(join6(sessionDir, "events.jsonl"), {
+      await appendJsonl(join5(sessionDir, EVENTS_FILE), {
         event: "session_start",
         session_id: event.sessionId,
         timestamp: event.timestamp,
         model: event.model ?? null
       });
+      await writeFile3(join5(sessionDir, HEARTBEAT_FILE), String(Date.now()));
       break;
     }
     case "stop": {
-      await writeFile3(join6(agentnoteDirPath, "session"), event.sessionId);
+      await writeFile3(join5(agentnoteDirPath, SESSION_FILE), event.sessionId);
       if (event.transcriptPath) {
-        await writeFile3(join6(sessionDir, "transcript_path"), event.transcriptPath);
+        await writeFile3(join5(sessionDir, TRANSCRIPT_PATH_FILE), event.transcriptPath);
       }
-      await appendJsonl(join6(sessionDir, "events.jsonl"), {
+      await appendJsonl(join5(sessionDir, EVENTS_FILE), {
         event: "stop",
         session_id: event.sessionId,
         timestamp: event.timestamp
@@ -712,47 +907,79 @@ async function hook() {
       break;
     }
     case "prompt": {
-      await appendJsonl(join6(sessionDir, "prompts.jsonl"), {
+      const rotateId = Date.now().toString(36);
+      await rotateLogs(sessionDir, rotateId, [PROMPTS_FILE, CHANGES_FILE, PRE_BLOBS_FILE]);
+      const turnPath = join5(sessionDir, TURN_FILE);
+      let turn = 0;
+      if (existsSync6(turnPath)) {
+        const raw2 = (await readFile5(turnPath, "utf-8")).trim();
+        turn = Number.parseInt(raw2, 10) || 0;
+      }
+      turn += 1;
+      await writeFile3(turnPath, String(turn));
+      await appendJsonl(join5(sessionDir, PROMPTS_FILE), {
         event: "prompt",
         timestamp: event.timestamp,
-        prompt: event.prompt
+        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;
       }
-      await appendJsonl(join6(sessionDir, "changes.jsonl"), {
+      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
+        session_id: event.sessionId,
+        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;
     }
     case "pre_commit": {
       const cmd = event.commitCommand ?? "";
-      if (!cmd.includes("Agentnote-Session") && event.sessionId) {
+      if (!cmd.includes(TRAILER_KEY) && event.sessionId) {
         process.stdout.write(
           JSON.stringify({
             hookSpecificOutput: {
               hookEventName: "PreToolUse",
               updatedInput: {
-                command: `${cmd} --trailer 'Agentnote-Session: ${event.sessionId}'`
+                command: `${cmd} --trailer '${TRAILER_KEY}: ${event.sessionId}'`
               }
             }
           })
@@ -762,47 +989,138 @@ async function hook() {
     }
     case "post_commit": {
       try {
-        await recordEntry(agentnoteDirPath, event.sessionId, event.transcriptPath);
+        await recordCommitEntry({
+          agentnoteDirPath,
+          sessionId: event.sessionId,
+          transcriptPath: event.transcriptPath
+        });
       } catch {
       }
       break;
     }
   }
 }
-async function recordEntry(agentnoteDirPath, sessionId, eventTranscriptPath) {
-  const sessionDir = join6(agentnoteDirPath, "sessions", sessionId);
-  const commitSha = await git(["rev-parse", "HEAD"]);
-  let commitFiles = [];
-  try {
-    const raw = await git(["diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"]);
-    commitFiles = raw.split("\n").filter(Boolean);
-  } catch {
+
+// src/commands/init.ts
+import { existsSync as existsSync7 } from "node:fs";
+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:
+  pull_request:
+    types: [opened, synchronize]
+concurrency:
+  group: agentnote-\${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+permissions:
+  contents: read
+  pull-requests: write
+jobs:
+  report:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: wasabeef/agentnote@v0
+`;
+async function init(args2) {
+  const skipHooks = args2.includes("--no-hooks");
+  const skipAction = args2.includes("--no-action");
+  const skipNotes = args2.includes("--no-notes");
+  const hooksOnly = args2.includes("--hooks");
+  const actionOnly = args2.includes("--action");
+  const repoRoot2 = await root();
+  const results = [];
+  await mkdir3(await agentnoteDir(), { recursive: true });
+  if (!skipHooks && !actionOnly) {
+    const adapter = claudeCode;
+    if (await adapter.isEnabled(repoRoot2)) {
+      results.push("  \xB7 hooks already configured");
+    } else {
+      await adapter.installHooks(repoRoot2);
+      results.push("  \u2713 hooks added to .claude/settings.json");
+    }
   }
-  const aiFiles = await readJsonlField(join6(sessionDir, "changes.jsonl"), "file");
-  const prompts = await readJsonlField(join6(sessionDir, "prompts.jsonl"), "prompt");
-  const transcriptPath = eventTranscriptPath ?? await readSavedTranscriptPath(sessionDir);
-  const adapter = claudeCode;
-  let interactions;
-  if (transcriptPath) {
-    const allInteractions = await adapter.extractInteractions(transcriptPath);
-    interactions = prompts.length > 0 && allInteractions.length > 0 ? allInteractions.slice(-prompts.length) : prompts.map((p) => ({ prompt: p, response: null }));
-  } else {
-    interactions = prompts.map((p) => ({ prompt: p, response: null }));
+  if (!skipAction && !hooksOnly) {
+    const workflowDir = join6(repoRoot2, ".github", "workflows");
+    const workflowPath = join6(workflowDir, "agentnote.yml");
+    if (existsSync7(workflowPath)) {
+      results.push("  \xB7 workflow already exists at .github/workflows/agentnote.yml");
+    } else {
+      await mkdir3(workflowDir, { recursive: true });
+      await writeFile4(workflowPath, WORKFLOW_TEMPLATE);
+      results.push("  \u2713 workflow created at .github/workflows/agentnote.yml");
+    }
   }
-  const entry = buildEntry({
-    sessionId,
-    interactions,
-    commitFiles,
-    aiFiles
-  });
-  await writeNote(commitSha, entry);
-  await rotateLogs(sessionDir, commitSha);
+  if (!skipNotes && !hooksOnly && !actionOnly) {
+    const { stdout } = await gitSafe(["config", "--get-all", "remote.origin.fetch"]);
+    if (stdout.includes(NOTES_REF_FULL)) {
+      results.push("  \xB7 git already configured to fetch notes");
+    } else {
+      await gitSafe(["config", "--add", "remote.origin.fetch", NOTES_FETCH_REFSPEC]);
+      results.push("  \u2713 git configured to auto-fetch notes on pull");
+    }
+  }
+  console.log("");
+  console.log("agentnote init");
+  console.log("");
+  for (const line of results) {
+    console.log(line);
+  }
+  const toCommit = [];
+  if (!skipHooks && !actionOnly) toCommit.push(".claude/settings.json");
+  if (!skipAction && !hooksOnly) {
+    const workflowPath = join6(repoRoot2, ".github", "workflows", "agentnote.yml");
+    if (existsSync7(workflowPath)) toCommit.push(".github/workflows/agentnote.yml");
+  }
+  if (toCommit.length > 0) {
+    console.log("");
+    console.log("  Next: commit and push these files");
+    console.log(`    git add ${toCommit.join(" ")}`);
+    console.log('    git commit -m "chore: enable agentnote session tracking"');
+    console.log("    git push");
+  }
+  console.log("");
 }
-async function readSavedTranscriptPath(sessionDir) {
-  const saved = join6(sessionDir, "transcript_path");
-  if (!existsSync7(saved)) return null;
-  const p = (await readFile5(saved, "utf-8")).trim();
-  return p || null;
+
+// src/commands/log.ts
+async function log(count = 10) {
+  const raw = await git([
+    "log",
+    `-${count}`,
+    `--format=%H	%h %s	%(trailers:key=${TRAILER_KEY},valueonly)`
+  ]);
+  if (!raw) {
+    console.log("no commits found");
+    return;
+  }
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    const fullSha = parts[0];
+    const commitPart = parts[1];
+    const sid = parts[2]?.trim();
+    if (!fullSha || !commitPart) continue;
+    if (!sid) {
+      console.log(commitPart);
+      continue;
+    }
+    let ratioStr = "";
+    let promptCount = "";
+    const note = await readNote(fullSha);
+    if (note) {
+      const entry = note;
+      ratioStr = `${entry.ai_ratio}%`;
+      promptCount = `${entry.interactions?.length ?? entry.prompts?.length ?? 0}p`;
+    }
+    if (ratioStr) {
+      console.log(`${commitPart}  [${sid.slice(0, 8)}\u2026 | \u{1F916}${ratioStr} | ${promptCount}]`);
+    } else {
+      console.log(`${commitPart}  [${sid.slice(0, 8)}\u2026]`);
+    }
+  }
 }
 
 // src/commands/pr.ts
@@ -813,12 +1131,7 @@ var MARKER_BEGIN = "<!-- agentnote-begin -->";
 var MARKER_END = "<!-- agentnote-end -->";
 async function collectReport(base) {
   const head = await git(["rev-parse", "--short", "HEAD"]);
-  const raw = await git([
-    "log",
-    "--reverse",
-    "--format=%H	%h	%s",
-    `${base}..HEAD`
-  ]);
+  const raw = await git(["log", "--reverse", "--format=%H	%h	%s", `${base}..HEAD`]);
   if (!raw.trim()) return null;
   const commits = [];
   for (const line of raw.trim().split("\n")) {
@@ -836,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;
     }
@@ -857,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,
@@ -871,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
   };
 }
@@ -908,7 +1234,7 @@ function renderMarkdown(report) {
       for (const { prompt, response } of c.interactions) {
         lines.push(`> **Prompt:** ${prompt}`);
         if (response) {
-          const truncated = response.length > 500 ? response.slice(0, 500) + "\u2026" : response;
+          const truncated = response.length > TRUNCATE_RESPONSE_PR ? `${response.slice(0, TRUNCATE_RESPONSE_PR)}\u2026` : response;
           lines.push(">");
           lines.push(`> **Response:** ${truncated.split("\n").join("\n> ")}`);
         }
@@ -944,7 +1270,9 @@ function renderChat(report) {
       continue;
     }
     lines.push(`<details>`);
-    lines.push(`<summary><code>${c.short}</code> ${c.message}${summaryExtra}${summaryFiles}</summary>`);
+    lines.push(
+      `<summary><code>${c.short}</code> ${c.message}${summaryExtra}${summaryFiles}</summary>`
+    );
     lines.push("");
     for (const { prompt, response } of c.interactions) {
       lines.push(`> **\u{1F9D1} Prompt**`);
@@ -953,7 +1281,7 @@ function renderChat(report) {
       if (response) {
         lines.push(`**\u{1F916} Response**`);
         lines.push("");
-        const truncated = response.length > 800 ? response.slice(0, 800) + "\u2026" : response;
+        const truncated = response.length > TRUNCATE_RESPONSE_CHAT ? `${response.slice(0, TRUNCATE_RESPONSE_CHAT)}\u2026` : response;
         lines.push(truncated);
         lines.push("");
       }
@@ -1007,27 +1335,23 @@ function upsertInDescription(existingBody, section) {
   if (existingBody.includes(MARKER_BEGIN)) {
     const before = existingBody.slice(0, existingBody.indexOf(MARKER_BEGIN));
     const after = existingBody.includes(MARKER_END) ? existingBody.slice(existingBody.indexOf(MARKER_END) + MARKER_END.length) : "";
-    return before.trimEnd() + "\n\n" + marked + after;
+    return `${before.trimEnd()}
+
+${marked}${after}`;
   }
-  return existingBody.trimEnd() + "\n\n" + marked;
+  return `${existingBody.trimEnd()}
+
+${marked}`;
 }
 async function updatePrDescription(prNumber, section) {
-  const { stdout: bodyJson } = await execFileAsync2("gh", [
-    "pr",
-    "view",
-    prNumber,
-    "--json",
-    "body"
-  ], { encoding: "utf-8" });
+  const { stdout: bodyJson } = await execFileAsync2(
+    "gh",
+    ["pr", "view", prNumber, "--json", "body"],
+    { encoding: "utf-8" }
+  );
   const currentBody = JSON.parse(bodyJson).body ?? "";
   const newBody = upsertInDescription(currentBody, section);
-  await execFileAsync2("gh", [
-    "pr",
-    "edit",
-    prNumber,
-    "--body",
-    newBody
-  ], { encoding: "utf-8" });
+  await execFileAsync2("gh", ["pr", "edit", prNumber, "--body", newBody], { encoding: "utf-8" });
 }
 async function pr(args2) {
   const isJson = args2.includes("--json");
@@ -1040,9 +1364,7 @@ async function pr(args2) {
   );
   const base = positional[0] ?? await detectBaseBranch();
   if (!base) {
-    console.error(
-      "error: could not detect base branch. pass it as argument: agentnote pr <base>"
-    );
+    console.error("error: could not detect base branch. pass it as argument: agentnote pr <base>");
     process.exit(1);
   }
   const report = await collectReport(base);
@@ -1050,7 +1372,7 @@ async function pr(args2) {
     if (isJson) {
       console.log(JSON.stringify({ error: "no commits found" }));
     } else {
-      console.log("no commits found between HEAD and " + base);
+      console.log(`no commits found between HEAD and ${base}`);
     }
     return;
   }
@@ -1070,7 +1392,7 @@ async function pr(args2) {
   }
 }
 function renderBar(ratio) {
-  const width = 5;
+  const width = BAR_WIDTH_COMPACT;
   const filled = Math.round(ratio / 100 * width);
   return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
 }
@@ -1079,20 +1401,199 @@ function basename(path) {
 }
 async function detectBaseBranch() {
   for (const name of ["main", "master", "develop"]) {
-    const { exitCode } = await gitSafe([
-      "rev-parse",
-      "--verify",
-      `origin/${name}`
-    ]);
+    const { exitCode } = await gitSafe(["rev-parse", "--verify", `origin/${name}`]);
     if (exitCode === 0) return `origin/${name}`;
   }
   return null;
 }
 
+// src/commands/session.ts
+async function session(sessionId) {
+  if (!sessionId) {
+    console.error("usage: agentnote session <session-id>");
+    process.exit(1);
+  }
+  const raw = await git([
+    "log",
+    "--all",
+    `--max-count=${MAX_COMMITS}`,
+    `--format=%H	%h %s	%(trailers:key=${TRAILER_KEY},valueonly)`
+  ]);
+  if (!raw) {
+    console.log("no commits found");
+    return;
+  }
+  const matches = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    const fullSha = parts[0];
+    const shortInfo = parts[1];
+    const trailer = parts[2]?.trim();
+    if (!fullSha || !shortInfo) continue;
+    if (trailer === sessionId) {
+      const note = await readNote(fullSha);
+      const entry = note;
+      matches.push({ sha: fullSha, shortInfo, entry });
+      continue;
+    }
+    if (!trailer) {
+      const note = await readNote(fullSha);
+      if (note && note.session_id === sessionId) {
+        const entry = note;
+        matches.push({ sha: fullSha, shortInfo, entry });
+      }
+    }
+  }
+  if (matches.length === 0) {
+    console.log(`no commits found for session ${sessionId}`);
+    return;
+  }
+  matches.reverse();
+  console.log(`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) {
+    let suffix = "";
+    if (m.entry) {
+      const promptCount = m.entry.interactions?.length ?? m.entry.prompts?.length ?? 0;
+      totalPrompts += promptCount;
+      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();
+  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}`);
+  }
+}
+
+// src/commands/show.ts
+import { stat } from "node:fs/promises";
+async function show(commitRef) {
+  const ref = commitRef ?? "HEAD";
+  const commitInfo = await git(["log", "-1", "--format=%h %s", ref]);
+  const commitSha = await git(["log", "-1", "--format=%H", ref]);
+  const sessionId = (await git(["log", "-1", `--format=%(trailers:key=${TRAILER_KEY},valueonly)`, ref])).trim();
+  console.log(`commit:  ${commitInfo}`);
+  if (!sessionId) {
+    console.log("session: none (no agentnote data)");
+    return;
+  }
+  console.log(`session: ${sessionId}`);
+  const raw = await readNote(commitSha);
+  const entry = raw;
+  if (entry) {
+    console.log();
+    const ratioBar = renderRatioBar(entry.ai_ratio);
+    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`
+    );
+    if (entry.files_in_commit.length > 0) {
+      console.log();
+      for (const file of entry.files_in_commit) {
+        const isAi = entry.files_by_ai.includes(file);
+        const marker = isAi ? "  \u{1F916}" : "  \u{1F464}";
+        console.log(`  ${file}${marker}`);
+      }
+    }
+    const legacy = entry;
+    const interactions = entry.interactions ?? (legacy.prompts ?? []).map((p) => ({
+      prompt: p,
+      response: null
+    }));
+    if (interactions.length > 0) {
+      console.log();
+      console.log(`prompts: ${interactions.length}`);
+      for (let i = 0; i < interactions.length; i++) {
+        const interaction = interactions[i];
+        console.log();
+        console.log(`  ${i + 1}. ${truncateLines(interaction.prompt, TRUNCATE_PROMPT)}`);
+        if (interaction.response) {
+          console.log(`     \u2192 ${truncateLines(interaction.response, TRUNCATE_RESPONSE_SHOW)}`);
+        }
+        if (interaction.files_touched && interaction.files_touched.length > 0) {
+          for (const file of interaction.files_touched) {
+            console.log(`     \u{1F4C4} ${file}`);
+          }
+        }
+      }
+    }
+  } else {
+    console.log("entry:   no agentnote note found for this commit");
+  }
+  const adapter = claudeCode;
+  const transcriptPath = adapter.findTranscript(sessionId);
+  if (transcriptPath) {
+    console.log();
+    const stats = await stat(transcriptPath);
+    const sizeKb = (stats.size / 1024).toFixed(1);
+    console.log(`transcript: ${transcriptPath} (${sizeKb} KB)`);
+  }
+}
+function renderRatioBar(ratio) {
+  const width = BAR_WIDTH_FULL;
+  const filled = Math.round(ratio / 100 * width);
+  const empty = width - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
+}
+function truncateLines(text, maxLen) {
+  const firstLine = text.split("\n")[0];
+  if (firstLine.length <= maxLen) return firstLine;
+  return `${firstLine.slice(0, maxLen)}\u2026`;
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync8 } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
+var VERSION = "0.1.7";
+async function status() {
+  console.log(`agentnote v${VERSION}`);
+  console.log();
+  const repoRoot2 = await root();
+  const adapter = claudeCode;
+  const hooksActive = await adapter.isEnabled(repoRoot2);
+  if (hooksActive) {
+    console.log("hooks:   active");
+  } else {
+    console.log("hooks:   not configured (run 'agentnote init')");
+  }
+  const sessionPath = await sessionFile();
+  if (existsSync8(sessionPath)) {
+    const sid = (await readFile6(sessionPath, "utf-8")).trim();
+    console.log(`session: ${sid.slice(0, 8)}\u2026`);
+  } else {
+    console.log("session: none");
+  }
+  const { stdout } = await gitSafe([
+    "log",
+    "-20",
+    `--format=%(trailers:key=${TRAILER_KEY},valueonly)`
+  ]);
+  const linked = stdout.split("\n").filter((line) => line.trim().length > 0).length;
+  console.log(`linked:  ${linked}/20 recent commits`);
+}
+
 // src/cli.ts
-var VERSION2 = "0.1.0";
+var VERSION2 = "0.1.7";
 var HELP = `
-agentnote \u2014 remember why your code changed
+agentnote v${VERSION2} \u2014 remember why your code changed
 
 usage:
   agentnote init                 set up hooks, workflow, and notes auto-fetch
@@ -1123,6 +1624,9 @@ switch (command) {
   case "status":
     await status();
     break;
+  case "session":
+    await session(args[0]);
+    break;
   case "hook":
     await hook();
     break;