@wasabeef/agentnote 0.1.4 → 0.1.6

package/dist/cli.js

@@ -1,82 +1,48 @@
 #!/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 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 } from "node:fs/promises";
+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: "Bash",
@@ -95,18 +61,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 +84,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 +102,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,7 +135,13 @@ 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":
@@ -182,7 +156,13 @@ 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
+          };
         }
         if (tool === "Bash" && isGitCommit(e.tool_input?.command ?? "")) {
           return { kind: "post_commit", sessionId: sid, timestamp: ts, transcriptPath: tp };
@@ -195,13 +175,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 +233,86 @@ 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");
-    }
-  }
-  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");
-    }
-  }
-  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");
-    } 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");
-    }
-  }
-  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 = join3(repoRoot2, ".github", "workflows", "agentnote.yml");
-    if (existsSync2(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");
+// 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
+    };
   }
-  console.log("");
+}
+async function repoRoot() {
+  return git(["rev-parse", "--show-toplevel"]);
 }
 
-// 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/entry.ts
+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);
+}
+function buildEntry(opts) {
+  return {
+    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)
+  };
+}
 
 // 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,61 +321,144 @@ async function readNote(commitSha) {
   }
 }
 
-// src/core/entry.ts
-var SCHEMA_VERSION = 1;
-var RESPONSE_MAX_LENGTH = 2e3;
-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 changeEntries = await readAllSessionJsonl(sessionDir, CHANGES_FILE);
+  const promptEntries = await readAllSessionJsonl(sessionDir, PROMPTS_FILE);
+  const hasTurnData = promptEntries.some((e) => typeof e.turn === "number" && e.turn > 0);
+  let aiFiles;
+  let prompts;
+  let relevantPromptEntries;
+  if (hasTurnData) {
+    aiFiles = [
+      ...new Set(
+        changeEntries.map((e) => e.file).filter((f) => f && commitFileSet.has(f))
+      )
+    ];
+    const relevantTurns = /* @__PURE__ */ new Set();
+    for (const entry2 of changeEntries) {
+      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 interactions;
+  if (transcriptPath && prompts.length > 0) {
+    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 entry = buildEntry({
+    sessionId: opts.sessionId,
+    interactions,
+    commitFiles,
+    aiFiles
+  });
+  await writeNote(commitSha, entry);
+  return { promptCount: interactions.length, aiRatio: entry.ai_ratio };
 }
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen) + "\u2026";
+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];
+    }
+  }
 }
-function buildEntry(opts) {
-  return {
-    v: SCHEMA_VERSION,
-    session_id: opts.sessionId,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    interactions: opts.interactions.map((i) => ({
-      prompt: i.prompt,
-      response: i.response ? truncate(i.response, RESPONSE_MAX_LENGTH) : null
-    })),
-    files_in_commit: opts.commitFiles,
-    files_by_ai: opts.aiFiles,
-    ai_ratio: calcAiRatio(opts.commitFiles, opts.aiFiles)
-  };
+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 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;
 }
 
-// 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, {
@@ -466,210 +474,44 @@ 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)}`);
-        }
-      }
-    }
-  } 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/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 { isAbsolute, join as join5, relative } from "node:path";
 
-// 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/core/rotate.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { readdir as readdir2, rename, unlink } 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);
+  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`));
     }
   }
 }
-
-// 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");
-  }
-  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`);
+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
-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) {
@@ -691,15 +533,15 @@ 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 writeFile2(join5(agentnoteDirPath, SESSION_FILE), event.sessionId);
       if (event.transcriptPath) {
-        await writeFile3(join6(sessionDir, "transcript_path"), event.transcriptPath);
+        await writeFile2(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,
@@ -708,11 +550,11 @@ async function hook() {
       break;
     }
     case "stop": {
-      await writeFile3(join6(agentnoteDirPath, "session"), event.sessionId);
+      await writeFile2(join5(agentnoteDirPath, SESSION_FILE), event.sessionId);
       if (event.transcriptPath) {
-        await writeFile3(join6(sessionDir, "transcript_path"), event.transcriptPath);
+        await writeFile2(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
@@ -720,10 +562,21 @@ async function hook() {
       break;
     }
     case "prompt": {
-      await appendJsonl(join6(sessionDir, "prompts.jsonl"), {
+      const rotateId = Date.now().toString(36);
+      await rotateLogs(sessionDir, rotateId);
+      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 writeFile2(turnPath, String(turn));
+      await appendJsonl(join5(sessionDir, PROMPTS_FILE), {
         event: "prompt",
         timestamp: event.timestamp,
-        prompt: event.prompt
+        prompt: event.prompt,
+        turn
       });
       break;
     }
@@ -735,7 +588,7 @@ async function hook() {
           const repoRoot2 = await realpath(rawRoot);
           let normalizedFile = filePath;
           if (repoRoot2.startsWith("/private") && !normalizedFile.startsWith("/private")) {
-            normalizedFile = "/private" + normalizedFile;
+            normalizedFile = `/private${normalizedFile}`;
           } else if (!repoRoot2.startsWith("/private") && normalizedFile.startsWith("/private")) {
             normalizedFile = normalizedFile.replace(/^\/private/, "");
           }
@@ -743,24 +596,31 @@ async function hook() {
         } catch {
         }
       }
-      await appendJsonl(join6(sessionDir, "changes.jsonl"), {
+      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(join5(sessionDir, CHANGES_FILE), {
         event: "file_change",
         timestamp: event.timestamp,
         tool: event.tool,
         file: filePath,
-        session_id: event.sessionId
+        session_id: event.sessionId,
+        turn
       });
       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}'`
               }
             }
           })
@@ -770,47 +630,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 writeFile3 } 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 writeFile3(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
@@ -821,12 +772,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")) {
@@ -916,7 +862,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> ")}`);
         }
@@ -952,7 +898,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**`);
@@ -961,7 +909,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("");
       }
@@ -1015,27 +963,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");
@@ -1048,9 +992,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);
@@ -1058,7 +1000,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;
   }
@@ -1078,7 +1020,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);
 }
@@ -1087,20 +1029,190 @@ 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 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;
+      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}%`);
+  }
+}
+
+// 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);
+    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 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.6";
+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.6";
 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
@@ -1131,6 +1243,9 @@ switch (command) {
   case "status":
     await status();
     break;
+  case "session":
+    await session(args[0]);
+    break;
   case "hook":
     await hook();
     break;