pi-redline 0.1.0

package/extensions/session-diff.ts

@@ -0,0 +1,1298 @@
+/**
+ * Session Diff Extension
+ *
+ * /session-diff opens an overlay showing every file edited/written during the
+ * current session, grouped by repo, with a syntax-highlighted git diff viewer.
+ *
+ * In the diff pane you can:
+ *   - select line ranges (`v` to enter select mode, ↑/↓ to extend),
+ *   - annotate the selection with a short note (`a`),
+ *   - review all annotations across all files (`A`),
+ *   - submit them as a single prompt back to the session (`S`).
+ *
+ * Inspired by Plannotator's code-review flow, but native and in-TUI.
+ */
+
+import {
+	getLanguageFromPath,
+	highlightCode,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+	Key,
+	matchesKey,
+	truncateToWidth,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+import { spawnSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+
+// ─── Catppuccin Mocha palette (rgb triples for ANSI true-color) ──────────────
+const C = {
+	mantle: "24;24;37",
+	crust: "17;17;27",
+	text: "205;214;244",
+	subtext1: "186;194;222",
+	subtext0: "166;173;200",
+	overlay1: "127;132;156",
+	overlay0: "108;112;134",
+	surface2: "88;91;112",
+	surface1: "69;71;90",
+	surface0: "49;50;68",
+	blue: "137;180;250",
+	lavender: "180;190;254",
+	sapphire: "116;199;236",
+	mauve: "203;166;247",
+	green: "166;227;161",
+	red: "243;139;168",
+	yellow: "249;226;175",
+	peach: "250;179;135",
+	teal: "148;226;213",
+};
+const fg = (rgb: string, s: string) => `\x1b[38;2;${rgb}m${s}\x1b[39m`;
+const bg = (rgb: string, s: string) => `\x1b[48;2;${rgb}m${s}\x1b[49m`;
+const bold = (s: string) => `\x1b[1m${s}\x1b[22m`;
+
+const BG_ADD = "27;48;36"; // dark green tint
+const BG_DEL = "61;26;34"; // dark red tint
+const BG_SEL = "62;70;100"; // selection (slightly brighter than surface0)
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+interface TouchedFile {
+	abs: string;
+	repo: string | null;
+	firstSeen: number;
+	lastSeen: number;
+}
+
+type DiffLineKind = "context" | "add" | "del" | "hunk" | "fileHeader" | "rawHeader";
+interface DiffLine {
+	kind: DiffLineKind;
+	oldNum?: number;
+	newNum?: number;
+	/** Code content with the leading +/-/space marker removed. */
+	text: string;
+	/** The original raw diff line. */
+	raw: string;
+}
+
+type AnnotKind = "fix" | "explain";
+interface Annotation {
+	id: string;
+	kind: AnnotKind;
+	file: string; // absolute path
+	repo: string | null;
+	/** Inclusive parsed-line indices into the cached DiffLine[] for the file. */
+	parsedStart: number;
+	parsedEnd: number;
+	/** Human-readable line range, e.g. "45-48" using new-side numbers when available. */
+	lineRangeLabel: string;
+	/** Snippet of the selected code (lines joined with \n). */
+	snippet: string;
+	note: string;
+	createdAt: number;
+}
+
+const ENTRY_TYPE = "session-diff:touched";
+
+type Mode = "scroll" | "select" | "annotate" | "review";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function findRepoRoot(filePath: string): string | null {
+	let dir = existsSync(filePath) && !isDir(filePath) ? dirname(filePath) : filePath;
+	if (!existsSync(dir)) dir = dirname(dir);
+	while (true) {
+		if (existsSync(`${dir}/.git`)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+function isDir(p: string): boolean {
+	try {
+		return statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+function absolutize(p: string, cwd: string): string {
+	if (!p) return p;
+	const cleaned = p.startsWith("@") ? p.slice(1) : p;
+	return isAbsolute(cleaned) ? cleaned : resolve(cwd, cleaned);
+}
+
+function repoLabel(repoRoot: string | null): string {
+	if (!repoRoot) return "(no repo)";
+	const home = process.env.HOME;
+	if (home && repoRoot === home) return "~";
+	if (home && repoRoot.startsWith(`${home}/`)) return `~/${repoRoot.slice(home.length + 1)}`;
+	return repoRoot;
+}
+
+/**
+ * Look up the canonical repo name + current branch for a repo/worktree root.
+ * For worktrees, `git rev-parse --git-common-dir` points at the original
+ * repo's `.git`, so its parent directory gives the project's real name.
+ * Cached per root since spawning git for every render would be wasteful.
+ */
+const repoInfoCache = new Map<string, { name: string; branch: string }>();
+function getRepoInfo(repoRoot: string | null): { name: string; branch: string } {
+	if (!repoRoot) return { name: "(no repo)", branch: "" };
+	const hit = repoInfoCache.get(repoRoot);
+	if (hit) return hit;
+	let name = repoRoot.split("/").pop() || repoRoot;
+	try {
+		const r = spawnSync(
+			"git",
+			["-C", repoRoot, "rev-parse", "--path-format=absolute", "--git-common-dir"],
+			{ encoding: "utf8" },
+		);
+		if (r.status === 0) {
+			const commonDir = (r.stdout || "").trim();
+			if (commonDir) {
+				const mainRoot = commonDir.replace(/\/\.git\/?$/, "");
+				const base = mainRoot.split("/").pop();
+				if (base) name = base;
+			}
+		}
+	} catch {}
+	let branch = "";
+	try {
+		const r = spawnSync("git", ["-C", repoRoot, "rev-parse", "--abbrev-ref", "HEAD"], {
+			encoding: "utf8",
+		});
+		if (r.status === 0) branch = (r.stdout || "").trim();
+	} catch {}
+	const info = { name, branch };
+	repoInfoCache.set(repoRoot, info);
+	return info;
+}
+
+function leftTruncate(s: string, width: number): string {
+	const w = visibleWidth(s);
+	if (w <= width) return s;
+	const overflow = w - width + 1;
+	return `…${s.slice(overflow)}`;
+}
+
+function relativeFileLabel(repo: string | null, abs: string): string {
+	if (!repo) return abs;
+	const rel = relative(repo, abs);
+	return rel || abs;
+}
+
+function padTo(width: number, s: string): string {
+	const w = visibleWidth(s);
+	if (w >= width) return truncateToWidth(s, width, "");
+	return s + " ".repeat(width - w);
+}
+
+// ─── Git ─────────────────────────────────────────────────────────────────────
+function gitDiff(repoRoot: string | null, abs: string): string {
+	const UFLAG = "--unified=999999";
+	if (!repoRoot) {
+		if (!existsSync(abs)) return "";
+		const r = spawnSync(
+			"git",
+			["diff", "--no-index", "--no-color", UFLAG, "/dev/null", abs],
+			{ encoding: "utf8" },
+		);
+		return r.stdout ?? "";
+	}
+	const rel = relative(repoRoot, abs);
+	const tracked =
+		spawnSync("git", ["-C", repoRoot, "ls-files", "--error-unmatch", "--", rel]).status === 0;
+	if (tracked) {
+		const r = spawnSync(
+			"git",
+			["-C", repoRoot, "diff", "HEAD", "--no-color", UFLAG, "--", rel],
+			{ encoding: "utf8" },
+		);
+		return r.stdout ?? "";
+	}
+	if (!existsSync(abs)) return "";
+	const r = spawnSync(
+		"git",
+		["-C", repoRoot, "diff", "--no-index", "--no-color", UFLAG, "/dev/null", abs],
+		{ encoding: "utf8" },
+	);
+	return r.stdout ?? "";
+}
+
+// ─── Diff parser ─────────────────────────────────────────────────────────────
+function parseDiff(raw: string): DiffLine[] {
+	const out: DiffLine[] = [];
+	let oldN = 0;
+	let newN = 0;
+	for (const ln of raw.split("\n")) {
+		if (ln.startsWith("@@")) {
+			const m = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(ln);
+			if (m) {
+				oldN = parseInt(m[1], 10);
+				newN = parseInt(m[2], 10);
+			}
+			out.push({ kind: "hunk", text: ln, raw: ln });
+			continue;
+		}
+		if (ln.startsWith("---") || ln.startsWith("+++")) {
+			out.push({ kind: "fileHeader", text: ln, raw: ln });
+			continue;
+		}
+		if (
+			ln.startsWith("diff ") ||
+			ln.startsWith("index ") ||
+			ln.startsWith("new file") ||
+			ln.startsWith("deleted file") ||
+			ln.startsWith("similarity ") ||
+			ln.startsWith("rename ") ||
+			ln.startsWith("Binary ")
+		) {
+			out.push({ kind: "rawHeader", text: ln, raw: ln });
+			continue;
+		}
+		if (ln.startsWith("+")) {
+			out.push({ kind: "add", newNum: newN, text: ln.slice(1), raw: ln });
+			newN++;
+			continue;
+		}
+		if (ln.startsWith("-")) {
+			out.push({ kind: "del", oldNum: oldN, text: ln.slice(1), raw: ln });
+			oldN++;
+			continue;
+		}
+		if (ln.startsWith(" ")) {
+			out.push({ kind: "context", oldNum: oldN, newNum: newN, text: ln.slice(1), raw: ln });
+			oldN++;
+			newN++;
+			continue;
+		}
+		// Empty line or unrecognized — keep flow.
+		if (ln === "") {
+			out.push({ kind: "context", oldNum: oldN, newNum: newN, text: "", raw: " " });
+			continue;
+		}
+		out.push({ kind: "rawHeader", text: ln, raw: ln });
+	}
+	return out;
+}
+
+// ─── Syntax highlight + diff colorizer ───────────────────────────────────────
+function highlightOne(content: string, lang: string | undefined): string {
+	if (!content) return content;
+	try {
+		return highlightCode(content, lang).join("");
+	} catch {
+		return content;
+	}
+}
+
+function colorDiffContent(line: DiffLine, lang: string | undefined): string {
+	switch (line.kind) {
+		case "fileHeader":
+			return fg(C.overlay1, line.raw);
+		case "rawHeader":
+			return fg(C.overlay0, line.raw);
+		case "hunk":
+			return fg(C.mauve, line.raw);
+		case "add":
+			return bg(BG_ADD, `${fg(C.green, "+")}${highlightOne(line.text, lang)}`);
+		case "del":
+			return bg(BG_DEL, `${fg(C.red, "-")}${highlightOne(line.text, lang)}`);
+		case "context":
+		default:
+			return ` ${highlightOne(line.text, lang)}`;
+	}
+}
+
+// ─── View ────────────────────────────────────────────────────────────────────
+type Row =
+	| { kind: "repo"; repo: string | null; collapsed: boolean; count: number }
+	| { kind: "repoMeta"; repo: string | null; tone: "branch" | "path"; text: string }
+	| { kind: "file"; repo: string | null; abs: string };
+
+interface RenderedDiff {
+	rows: string[]; // colored, gutter-prefixed, wrapped lines ready to slice
+	rowToParsed: number[]; // rendered row index → parsed DiffLine index
+	parsedToFirstRow: number[]; // parsed index → first rendered row
+	gutterW: number;
+}
+
+class SessionDiffView {
+	private rows: Row[] = [];
+	private leftSelected = 0;
+	private leftScroll = 0;
+	private collapsed = new Set<string>();
+	private focus: "left" | "right" = "left";
+
+	// Right-pane mode state
+	private mode: Mode = "scroll";
+	private cursor = 0; // parsed-line index for current file
+	private selAnchor: number | null = null;
+	private diffScrollByFile = new Map<string, number>(); // abs → first visible rendered row
+	private annotInput = "";
+	private pendingAnnotKind: AnnotKind = "fix";
+
+	// Review-pane state
+	private reviewSel = 0;
+
+	// Caches
+	private parsedCache = new Map<string, DiffLine[]>(); // abs → parsed
+	private rendered = new Map<string, RenderedDiff>(); // key=abs@@width@@selSig → rendered
+	private cachedWidth?: number;
+	private cachedHeight?: number;
+	private cachedLines?: string[];
+
+	public onClose?: () => void;
+	public onSubmit?: (prompt: string) => void;
+
+	constructor(
+		private files: TouchedFile[],
+		/** Annotations live in the extension closure so they survive overlay close. */
+		private annotations: Annotation[],
+	) {
+		this.rebuildRows();
+	}
+
+	// ── Left tree ────────────────────────────────────────────────────────────
+	private repoKey(r: string | null): string {
+		return r ?? "__none__";
+	}
+
+	private rebuildRows() {
+		const groups = new Map<string, { repo: string | null; files: TouchedFile[] }>();
+		for (const f of this.files) {
+			const k = this.repoKey(f.repo);
+			if (!groups.has(k)) groups.set(k, { repo: f.repo, files: [] });
+			groups.get(k)!.files.push(f);
+		}
+		for (const g of groups.values()) g.files.sort((a, b) => b.lastSeen - a.lastSeen);
+		this.rows = [];
+		for (const [, g] of groups) {
+			const collapsed = this.collapsed.has(this.repoKey(g.repo));
+			this.rows.push({ kind: "repo", repo: g.repo, collapsed, count: g.files.length });
+			if (!collapsed) {
+				const info = getRepoInfo(g.repo);
+				if (info.branch) {
+					this.rows.push({ kind: "repoMeta", repo: g.repo, tone: "branch", text: info.branch });
+				}
+				if (g.repo) {
+					this.rows.push({ kind: "repoMeta", repo: g.repo, tone: "path", text: repoLabel(g.repo) });
+				}
+				for (const f of g.files) this.rows.push({ kind: "file", repo: g.repo, abs: f.abs });
+			}
+		}
+		if (this.leftSelected >= this.rows.length)
+			this.leftSelected = Math.max(0, this.rows.length - 1);
+		while (this.rows[this.leftSelected]?.kind === "repoMeta") this.leftSelected++;
+		if (this.leftSelected >= this.rows.length)
+			this.leftSelected = Math.max(0, this.rows.length - 1);
+	}
+
+	private currentFile(): { abs: string; repo: string | null } | null {
+		const r = this.rows[this.leftSelected];
+		if (!r || r.kind !== "file") return null;
+		return { abs: r.abs, repo: r.repo };
+	}
+
+	private getParsed(abs: string, repo: string | null): DiffLine[] {
+		const hit = this.parsedCache.get(abs);
+		if (hit) return hit;
+		const parsed = parseDiff(gitDiff(repo, abs));
+		this.parsedCache.set(abs, parsed);
+		return parsed;
+	}
+
+	private firstCodeLine(parsed: DiffLine[]): number {
+		for (let i = 0; i < parsed.length; i++) {
+			if (
+				parsed[i].kind === "context" ||
+				parsed[i].kind === "add" ||
+				parsed[i].kind === "del"
+			)
+				return i;
+		}
+		return 0;
+	}
+
+	private isCodeLine(p: DiffLine): boolean {
+		return p.kind === "context" || p.kind === "add" || p.kind === "del";
+	}
+
+	// ── Diff rendering with gutter / cursor / selection ──────────────────────
+	private selRange(): [number, number] | null {
+		if (this.mode !== "select" && this.mode !== "annotate") return null;
+		if (this.selAnchor == null) return [this.cursor, this.cursor];
+		return [Math.min(this.selAnchor, this.cursor), Math.max(this.selAnchor, this.cursor)];
+	}
+
+	private buildRendered(abs: string, repo: string | null, width: number): RenderedDiff {
+		const parsed = this.getParsed(abs, repo);
+		const lang = getLanguageFromPath(abs);
+
+		// Determine gutter width based on max line number.
+		let maxNum = 1;
+		for (const p of parsed) {
+			if (p.oldNum != null && p.oldNum > maxNum) maxNum = p.oldNum;
+			if (p.newNum != null && p.newNum > maxNum) maxNum = p.newNum;
+		}
+		const numW = Math.max(2, String(maxNum).length);
+		const gutterW = 1 /* cursor col */ + numW + 1 /* sp */ + numW + 1 /* sp */ + 1 /* │ */ + 1 /* sp */;
+		const codeW = Math.max(10, width - gutterW);
+
+		const sel = this.selRange();
+		const cursor = this.cursor;
+
+		const rows: string[] = [];
+		const rowToParsed: number[] = [];
+		const parsedToFirstRow: number[] = new Array(parsed.length).fill(-1);
+
+		for (let i = 0; i < parsed.length; i++) {
+			const p = parsed[i];
+			const inSel = !!sel && i >= sel[0] && i <= sel[1];
+			const isCursor = this.focus === "right" && (this.mode === "select" || this.mode === "annotate") && i === cursor;
+			const isAnnotated = this.annotations.some(
+				(a) => a.file === abs && i >= a.parsedStart && i <= a.parsedEnd,
+			);
+
+			// Gutter: cursor col, old, new, separator
+			let cursorCol: string;
+			if (isCursor) cursorCol = fg(C.peach, "▌");
+			else if (isAnnotated) cursorCol = fg(C.yellow, "│");
+			else cursorCol = " ";
+
+			let oldStr: string;
+			let newStr: string;
+			if (p.kind === "hunk" || p.kind === "fileHeader" || p.kind === "rawHeader") {
+				oldStr = " ".repeat(numW);
+				newStr = " ".repeat(numW);
+			} else {
+				oldStr =
+					p.oldNum != null
+						? (p.kind === "del" ? fg(C.red, String(p.oldNum).padStart(numW)) : fg(C.overlay0, String(p.oldNum).padStart(numW)))
+						: " ".repeat(numW);
+				newStr =
+					p.newNum != null
+						? (p.kind === "add" ? fg(C.green, String(p.newNum).padStart(numW)) : fg(C.overlay0, String(p.newNum).padStart(numW)))
+						: " ".repeat(numW);
+			}
+			const sepCol = fg(isCursor ? C.peach : C.surface1, "│");
+			const gutter = `${cursorCol}${oldStr} ${newStr} ${sepCol} `;
+			const blankGutter = ` ${" ".repeat(numW)} ${" ".repeat(numW)} ${fg(C.surface1, "│")} `;
+
+			const colored = colorDiffContent(p, lang);
+			const wrapped = wrapTextWithAnsi(colored, codeW);
+			if (wrapped.length === 0) wrapped.push("");
+
+			parsedToFirstRow[i] = rows.length;
+			for (let w = 0; w < wrapped.length; w++) {
+				let body = wrapped[w];
+				if (inSel) body = bg(BG_SEL, padTo(codeW, body));
+				const g = w === 0 ? gutter : blankGutter;
+				rows.push(`${g}${body}`);
+				rowToParsed.push(i);
+			}
+		}
+
+		return { rows, rowToParsed, parsedToFirstRow, gutterW };
+	}
+
+	// Build a stable signature for the cache key.
+	private renderSig(abs: string, width: number): string {
+		const sel = this.selRange();
+		const selKey = sel ? `${sel[0]}-${sel[1]}` : "none";
+		const annotKey = this.annotations
+			.filter((a) => a.file === abs)
+			.map((a) => `${a.parsedStart}-${a.parsedEnd}`)
+			.join(",");
+		return `${abs}@@${width}@@${this.focus}@@${this.mode}@@${this.cursor}@@${selKey}@@${annotKey}`;
+	}
+
+	private getRendered(abs: string, repo: string | null, width: number): RenderedDiff {
+		const key = this.renderSig(abs, width);
+		const hit = this.rendered.get(key);
+		if (hit) return hit;
+		const r = this.buildRendered(abs, repo, width);
+		// Keep the cache small.
+		if (this.rendered.size > 16) this.rendered.clear();
+		this.rendered.set(key, r);
+		return r;
+	}
+
+	private getDiffScroll(abs: string): number {
+		return this.diffScrollByFile.get(abs) ?? 0;
+	}
+	private setDiffScroll(abs: string, v: number) {
+		this.diffScrollByFile.set(abs, Math.max(0, v));
+	}
+
+	// ── Input ────────────────────────────────────────────────────────────────
+	handleInput(data: string): void {
+		// Annotate mode: capture text input.
+		if (this.mode === "annotate") {
+			if (matchesKey(data, Key.escape)) {
+				this.mode = "select";
+				this.annotInput = "";
+				this.invalidate();
+				return;
+			}
+			if (matchesKey(data, Key.enter)) {
+				this.commitAnnotation();
+				this.invalidate();
+				return;
+			}
+			if (matchesKey(data, Key.backspace)) {
+				this.annotInput = this.annotInput.slice(0, -1);
+				this.invalidate();
+				return;
+			}
+			if (data.length === 1 && data.charCodeAt(0) >= 32) {
+				this.annotInput += data;
+				this.invalidate();
+				return;
+			}
+			return;
+		}
+
+		// Review mode
+		if (this.mode === "review") {
+			if (matchesKey(data, Key.escape) || data === "q") {
+				this.mode = "scroll";
+				this.invalidate();
+				return;
+			}
+			if (matchesKey(data, Key.up) || data === "k") {
+				if (this.reviewSel > 0) this.reviewSel--;
+				this.invalidate();
+				return;
+			}
+			if (matchesKey(data, Key.down) || data === "j") {
+				if (this.reviewSel < this.annotations.length - 1) this.reviewSel++;
+				this.invalidate();
+				return;
+			}
+			if (data === "d" || matchesKey(data, Key.delete)) {
+				this.annotations.splice(this.reviewSel, 1);
+				if (this.reviewSel >= this.annotations.length) this.reviewSel = Math.max(0, this.annotations.length - 1);
+				this.invalidate();
+				return;
+			}
+			if (data === "S") {
+				this.submit();
+				return;
+			}
+			if (matchesKey(data, Key.enter)) {
+				// Jump to the annotation's file + line
+				const a = this.annotations[this.reviewSel];
+				if (a) this.focusAnnotation(a);
+				return;
+			}
+			return;
+		}
+
+		// Global keys
+		if (matchesKey(data, Key.escape) || data === "q") {
+			this.onClose?.();
+			return;
+		}
+		if (data === "A") {
+			if (this.annotations.length === 0) return;
+			this.mode = "review";
+			this.reviewSel = 0;
+			this.invalidate();
+			return;
+		}
+		if (data === "S") {
+			this.submit();
+			return;
+		}
+
+		if (this.focus === "left") {
+			this.handleLeft(data);
+			return;
+		}
+
+		// Right pane
+		const cf = this.currentFile();
+		if (!cf) return;
+		const parsed = this.getParsed(cf.abs, cf.repo);
+
+		if (this.mode === "scroll") {
+			if (matchesKey(data, Key.up) || data === "k") this.setDiffScroll(cf.abs, this.getDiffScroll(cf.abs) - 1);
+			else if (matchesKey(data, Key.down) || data === "j") this.setDiffScroll(cf.abs, this.getDiffScroll(cf.abs) + 1);
+			else if (data === " " || data === "\x06") this.setDiffScroll(cf.abs, this.getDiffScroll(cf.abs) + 10);
+			else if (data === "\x02") this.setDiffScroll(cf.abs, this.getDiffScroll(cf.abs) - 10);
+			else if (matchesKey(data, Key.left) || data === "h") this.focus = "left";
+			else if (matchesKey(data, Key.home) || data === "g") this.setDiffScroll(cf.abs, 0);
+			else if (data === "v") {
+				this.mode = "select";
+				// Place cursor at the first visible code line; no anchor yet.
+				const r = this.getRendered(cf.abs, cf.repo, this.lastRightW);
+				const firstVisibleRow = this.getDiffScroll(cf.abs);
+				const firstVisibleParsed = r.rowToParsed[firstVisibleRow] ?? 0;
+				let c = firstVisibleParsed;
+				while (c < parsed.length && !this.isCodeLine(parsed[c])) c++;
+				if (c >= parsed.length) c = this.firstCodeLine(parsed);
+				this.cursor = c;
+				this.selAnchor = null;
+			}
+			this.invalidate();
+			return;
+		}
+
+		if (this.mode === "select") {
+			if (matchesKey(data, Key.escape)) {
+				// If a range is in progress, just drop it; another esc exits select.
+				if (this.selAnchor != null) {
+					this.selAnchor = null;
+				} else {
+					this.mode = "scroll";
+				}
+				this.invalidate();
+				return;
+			}
+			// Arrows: move cursor; extend range if an anchor was dropped.
+			if (matchesKey(data, Key.up) || data === "k") {
+				this.moveCursor(parsed, -1, this.selAnchor != null);
+			} else if (matchesKey(data, Key.down) || data === "j") {
+				this.moveCursor(parsed, +1, this.selAnchor != null);
+			} else if (data === " ") {
+				// First space  -> drop anchor at cursor (range begins).
+				// Second space -> confirm range and open the annotation input.
+				if (this.selAnchor == null) {
+					this.selAnchor = this.cursor;
+				} else {
+					this.mode = "annotate";
+					this.annotInput = "";
+					this.pendingAnnotKind = "fix";
+				}
+			} else if (data === "o") {
+				if (this.selAnchor != null) {
+					const t = this.cursor;
+					this.cursor = this.selAnchor;
+					this.selAnchor = t;
+				}
+			} else if (data === "a" || matchesKey(data, Key.enter)) {
+				if (this.selAnchor == null) this.selAnchor = this.cursor;
+				this.mode = "annotate";
+				this.annotInput = "";
+				this.pendingAnnotKind = "fix";
+			} else if (data === "x" || data === "X") {
+				if (this.selAnchor == null) this.selAnchor = this.cursor;
+				this.mode = "annotate";
+				this.annotInput = "";
+				this.pendingAnnotKind = "explain";
+			} else if (matchesKey(data, Key.left) || data === "h") {
+				this.mode = "scroll";
+				this.selAnchor = null;
+			}
+			this.ensureCursorVisible(cf.abs, cf.repo);
+			this.invalidate();
+			return;
+		}
+	}
+
+	private lastRightW = 80;
+
+	private handleLeft(data: string): void {
+		if (matchesKey(data, Key.up) || data === "k") {
+			if (this.leftSelected > 0) {
+				this.leftSelected--;
+				while (this.leftSelected > 0 && this.rows[this.leftSelected].kind === "repoMeta")
+					this.leftSelected--;
+			}
+		} else if (matchesKey(data, Key.down) || data === "j") {
+			if (this.leftSelected < this.rows.length - 1) {
+				this.leftSelected++;
+				while (
+					this.leftSelected < this.rows.length - 1 &&
+					this.rows[this.leftSelected].kind === "repoMeta"
+				)
+					this.leftSelected++;
+			}
+		} else if (matchesKey(data, Key.left) || data === "h") {
+			const r = this.rows[this.leftSelected];
+			if (r?.kind === "repo" && !r.collapsed) {
+				this.collapsed.add(this.repoKey(r.repo));
+				this.rebuildRows();
+			} else if (r?.kind === "file") {
+				for (let i = this.leftSelected - 1; i >= 0; i--) {
+					if (this.rows[i].kind === "repo") {
+						this.leftSelected = i;
+						break;
+					}
+				}
+			}
+		} else if (matchesKey(data, Key.right) || matchesKey(data, Key.enter) || data === "l") {
+			const r = this.rows[this.leftSelected];
+			if (r?.kind === "repo") {
+				if (r.collapsed) {
+					this.collapsed.delete(this.repoKey(r.repo));
+					this.rebuildRows();
+				}
+			} else if (r?.kind === "file") {
+				this.focus = "right";
+				this.mode = "scroll";
+				this.selAnchor = null;
+			}
+		}
+		this.invalidate();
+	}
+
+	private moveCursor(parsed: DiffLine[], delta: number, shift: boolean) {
+		if (shift && this.selAnchor == null) this.selAnchor = this.cursor;
+		else if (!shift) this.selAnchor = null;
+		let c = this.cursor;
+		while (true) {
+			c += delta;
+			if (c < 0 || c >= parsed.length) {
+				c = Math.max(0, Math.min(parsed.length - 1, c));
+				break;
+			}
+			if (this.isCodeLine(parsed[c])) break;
+		}
+		this.cursor = c;
+	}
+
+	private ensureCursorVisible(abs: string, repo: string | null) {
+		const r = this.getRendered(abs, repo, this.lastRightW);
+		const row = r.parsedToFirstRow[this.cursor] ?? 0;
+		const top = this.getDiffScroll(abs);
+		const innerH = this.lastInnerH;
+		if (row < top) this.setDiffScroll(abs, row);
+		else if (row >= top + innerH) this.setDiffScroll(abs, row - innerH + 1);
+	}
+
+	private lastInnerH = 10;
+
+	// ── Annotation lifecycle ────────────────────────────────────────────────
+	private commitAnnotation() {
+		const cf = this.currentFile();
+		if (!cf) {
+			this.mode = "scroll";
+			return;
+		}
+		const note = this.annotInput.trim();
+		this.annotInput = "";
+		// For "explain" annotations an empty note is fine — the LLM is asked to
+		// explain the snippet on its own. Fix-mode requires a note.
+		if (!note && this.pendingAnnotKind !== "explain") {
+			this.mode = "select";
+			return;
+		}
+		const sel = this.selRange();
+		if (!sel) {
+			this.mode = "select";
+			return;
+		}
+		const parsed = this.getParsed(cf.abs, cf.repo);
+		const [s, e] = sel;
+		// Build a human range label using new-side line numbers if available, else old.
+		const linesNew: number[] = [];
+		const linesOld: number[] = [];
+		const snippetLines: string[] = [];
+		for (let i = s; i <= e; i++) {
+			const p = parsed[i];
+			if (p.newNum != null) linesNew.push(p.newNum);
+			if (p.oldNum != null) linesOld.push(p.oldNum);
+			if (this.isCodeLine(p)) {
+				const prefix = p.kind === "add" ? "+ " : p.kind === "del" ? "- " : "  ";
+				snippetLines.push(`${prefix}${p.text}`);
+			}
+		}
+		let rangeLabel: string;
+		if (linesNew.length > 0) {
+			rangeLabel = linesNew.length === 1 ? `L${linesNew[0]}` : `L${linesNew[0]}-${linesNew[linesNew.length - 1]}`;
+		} else if (linesOld.length > 0) {
+			rangeLabel = linesOld.length === 1 ? `L${linesOld[0]} (old)` : `L${linesOld[0]}-${linesOld[linesOld.length - 1]} (old)`;
+		} else {
+			rangeLabel = "(no line range)";
+		}
+		this.annotations.push({
+			id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+			kind: this.pendingAnnotKind,
+			file: cf.abs,
+			repo: cf.repo,
+			parsedStart: s,
+			parsedEnd: e,
+			lineRangeLabel: rangeLabel,
+			snippet: snippetLines.join("\n"),
+			note,
+			createdAt: Date.now(),
+		});
+		this.mode = "select";
+		this.selAnchor = null;
+	}
+
+	private focusAnnotation(a: Annotation) {
+		// Switch left selection to the file
+		const idx = this.rows.findIndex((r) => r.kind === "file" && r.abs === a.file);
+		if (idx >= 0) this.leftSelected = idx;
+		this.focus = "right";
+		this.mode = "select";
+		this.cursor = a.parsedStart;
+		this.selAnchor = a.parsedEnd;
+		this.ensureCursorVisible(a.file, a.repo);
+		this.invalidate();
+	}
+
+	private submit() {
+		if (this.annotations.length === 0) return;
+		const fixes = this.annotations.filter((a) => a.kind === "fix");
+		const explains = this.annotations.filter((a) => a.kind === "explain");
+		const sections: string[] = [];
+
+		const renderGroup = (items: Annotation[]) => {
+			const byFile = new Map<string, Annotation[]>();
+			for (const a of items) {
+				if (!byFile.has(a.file)) byFile.set(a.file, []);
+				byFile.get(a.file)!.push(a);
+			}
+			for (const [file, arr] of byFile) {
+				const repo = arr[0].repo;
+				const rel = relativeFileLabel(repo, file);
+				sections.push(`\n### \`${rel}\`${repo ? ` _(repo: ${repoLabel(repo)})_` : ""}`);
+				for (const a of arr) {
+					const label = a.note ? ` — ${a.note}` : "";
+					sections.push(`\n**${a.lineRangeLabel}**${label}`);
+					if (a.snippet) {
+						sections.push("```diff");
+						sections.push(a.snippet);
+						sections.push("```");
+					}
+				}
+			}
+		};
+
+		if (fixes.length > 0 && explains.length > 0) {
+			sections.push(
+				"I'm reviewing the changes you made in this session. Some annotations request fixes, others ask for an explanation — please respond to each:",
+			);
+			sections.push("\n## Fixes requested\nPlease apply each of the following changes:");
+			renderGroup(fixes);
+			sections.push(
+				"\n## Explanations requested\nFor each of the following, explain what the code does, why it was written this way, and any non-obvious implications. Do not modify the code.",
+			);
+			renderGroup(explains);
+		} else if (explains.length > 0) {
+			sections.push(
+				"For each of the following code regions from this session, please explain what the code does, why it was written this way, and any non-obvious implications. Do not modify the code unless I explicitly ask.",
+			);
+			renderGroup(explains);
+		} else {
+			sections.push(
+				"I'm reviewing the changes you made in this session. Here are my inline annotations — please address each:",
+			);
+			renderGroup(fixes);
+		}
+		const prompt = sections.join("\n");
+		this.onSubmit?.(prompt);
+	}
+
+	// ── Render ──────────────────────────────────────────────────────────────
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+
+	render(width: number): string[] {
+		const termRows = process.stdout.rows ?? 30;
+		const totalHeight = Math.max(14, Math.min(termRows - 4, Math.floor(termRows * 0.82)));
+
+		if (
+			this.cachedLines &&
+			this.cachedWidth === width &&
+			this.cachedHeight === totalHeight
+		) {
+			return this.cachedLines;
+		}
+
+		const innerW = width - 2;
+		const leftWidth = Math.max(26, Math.min(48, Math.floor(innerW * 0.32)));
+		const rightWidth = innerW - leftWidth - 1;
+		const headerH = 1;
+		const footerH = this.mode === "annotate" ? 2 : 1;
+		const dividerH = 2;
+		const bodyH = Math.max(3, totalHeight - 2 - headerH - footerH - dividerH);
+
+		this.lastRightW = rightWidth - 1; // 1 for inner left padding
+		this.lastInnerH = bodyH - 2; // 2 = file header + rule inside right pane
+
+		const border = (s: string) => fg(C.mauve, s);
+		const top = border(`╭${"─".repeat(innerW)}╮`);
+		const bot = border(`╰${"─".repeat(innerW)}╯`);
+		const rule = border("├") + fg(C.surface1, "─".repeat(innerW)) + border("┤");
+		const V = border("│");
+
+		const header = `${V}${padTo(innerW, this.renderHeader(innerW))}${V}`;
+
+		const left = this.renderLeft(leftWidth, bodyH);
+		const right = this.mode === "review"
+			? this.renderReview(rightWidth, bodyH)
+			: this.renderRight(rightWidth, bodyH);
+		const sep = fg(C.surface1, "│");
+
+		const body: string[] = [];
+		for (let i = 0; i < bodyH; i++) {
+			const l = left[i] ?? padTo(leftWidth, "");
+			const r = right[i] ?? padTo(rightWidth, "");
+			body.push(`${V}${l}${sep}${r}${V}`);
+		}
+
+		const footerLines = this.renderFooter(innerW);
+		const footerWrapped = footerLines.map((ln) => `${V}${padTo(innerW, ln)}${V}`);
+
+		const lines = [top, header, rule, ...body, rule, ...footerWrapped, bot];
+		const tinted = lines.map((ln) => bg(C.mantle, padTo(width, ln)));
+		this.cachedLines = tinted;
+		this.cachedWidth = width;
+		this.cachedHeight = totalHeight;
+		return tinted;
+	}
+
+	private renderHeader(width: number): string {
+		const title = bold(fg(C.lavender, " Session Diff "));
+		const hint = fg(
+			C.overlay1,
+			` ${this.files.length} file${this.files.length === 1 ? "" : "s"} touched`,
+		);
+		const annot = this.annotations.length > 0
+			? `  ${fg(C.yellow, `${this.annotations.length} annotation${this.annotations.length === 1 ? "" : "s"}`)}`
+			: "";
+		const modeTag = this.mode !== "scroll"
+			? `  ${bg(C.surface1, fg(C.peach, ` ${this.mode.toUpperCase()} `))}`
+			: "";
+		return padTo(width, title + hint + annot + modeTag);
+	}
+
+	private renderFooter(width: number): string[] {
+		if (this.mode === "annotate") {
+			const sel = this.selRange();
+			const cf = this.currentFile();
+			let rangeLabel = "?";
+			if (sel && cf) {
+				const parsed = this.getParsed(cf.abs, cf.repo);
+				const [s, e] = sel;
+				const ns = parsed[s]?.newNum ?? parsed[s]?.oldNum;
+				const ne = parsed[e]?.newNum ?? parsed[e]?.oldNum;
+				rangeLabel = ns != null && ne != null ? (ns === ne ? `L${ns}` : `L${ns}-${ne}`) : "?";
+			}
+			const kindTag =
+				this.pendingAnnotKind === "explain"
+					? bg(C.surface1, fg(C.sapphire, " explain "))
+					: bg(C.surface1, fg(C.yellow, " fix "));
+			const icon = this.pendingAnnotKind === "explain" ? fg(C.sapphire, "?") : fg(C.yellow, "✎");
+			const placeholder =
+				this.pendingAnnotKind === "explain"
+					? "what to explain (optional):"
+					: "note:";
+			const prompt = ` ${kindTag} ${icon} ${fg(C.subtext0, `${placeholder} (${rangeLabel})`)} ${fg(C.text, this.annotInput)}${fg(C.peach, "▏")}`;
+			const help = ` ${fg(C.peach, "⏎")} ${fg(C.subtext0, "save")}  ·  ${fg(C.peach, "esc")} ${fg(C.subtext0, "cancel")}`;
+			return [padTo(width, prompt), padTo(width, help)];
+		}
+		if (this.mode === "review") {
+			const segs: [string, string][] = [
+				["↑↓", "navigate"],
+				["⏎", "jump to file"],
+				["d", "delete"],
+				["S", `submit (${this.annotations.length})`],
+				["esc", "back"],
+			];
+			return [padTo(width, " " + segs.map(([k, v]) => `${fg(C.peach, k)} ${fg(C.subtext0, v)}`).join(fg(C.overlay0, "  ·  ")))];
+		}
+		let segs: [string, string][];
+		if (this.focus === "left") {
+			segs = [
+				["↑↓", "navigate"],
+				["←", "collapse"],
+				["→/⏎", "open diff"],
+				["A", `review (${this.annotations.length})`],
+				["q", "close"],
+			];
+		} else if (this.mode === "select") {
+			const annotN = this.annotations.length;
+			segs = this.selAnchor == null
+				? [
+					["↑↓", "move"],
+					["space", "start range"],
+					["a/⏎", "annotate (fix)"],
+					["x", "annotate (explain)"],
+					["A", `review (${annotN})`],
+					["S", "submit"],
+					["esc", "exit"],
+				]
+				: [
+					["↑↓", "extend"],
+					["a/space", "end + fix"],
+					["x", "end + explain"],
+					["o", "swap ends"],
+					["esc", "drop range"],
+				];
+		} else {
+			segs = [
+				["↑↓", "scroll"],
+				["v", "select lines"],
+				["←", "back"],
+				["A", `review (${this.annotations.length})`],
+				["S", "submit"],
+				["q", "close"],
+			];
+		}
+		return [padTo(width, " " + segs.map(([k, v]) => `${fg(C.peach, k)} ${fg(C.subtext0, v)}`).join(fg(C.overlay0, "  ·  ")))];
+	}
+
+	private renderLeft(width: number, height: number): string[] {
+		if (this.leftSelected < this.leftScroll) this.leftScroll = this.leftSelected;
+		if (this.leftSelected >= this.leftScroll + height)
+			this.leftScroll = this.leftSelected - height + 1;
+
+		const visible = this.rows.slice(this.leftScroll, this.leftScroll + height);
+		const out: string[] = [];
+		for (let i = 0; i < visible.length; i++) {
+			const idx = this.leftScroll + i;
+			const r = visible[i];
+			const isSel = idx === this.leftSelected;
+			out.push(this.renderRow(r, isSel, width));
+		}
+		while (out.length < height) out.push(padTo(width, ""));
+		return out;
+	}
+
+	private renderRow(r: Row, selected: boolean, width: number): string {
+		const prefix = selected && this.focus === "left" ? fg(C.peach, "▌") : " ";
+		let body: string;
+		if (r.kind === "repo") {
+			const arrow = r.collapsed ? fg(C.overlay1, "▸") : fg(C.overlay1, "▾");
+			const count = fg(C.overlay0, ` (${r.count})`);
+			const countW = visibleWidth(` (${r.count})`);
+			const nameMax = Math.max(8, width - 4 - countW);
+			const { name: repoName } = getRepoInfo(r.repo);
+			const label = leftTruncate(repoName, nameMax);
+			const name = fg(C.blue, bold(label));
+			body = `${arrow} ${name}${count}`;
+		} else if (r.kind === "repoMeta") {
+			if (r.tone === "branch") {
+				body = `    ${fg(C.teal, "")} ${fg(C.subtext0, r.text)}`;
+			} else {
+				const max = Math.max(8, width - 5);
+				body = `    ${fg(C.overlay0, leftTruncate(r.text, max))}`;
+			}
+		} else {
+			const fileAnnots = this.annotations.filter((a) => a.file === r.abs).length;
+			const badge = fileAnnots > 0 ? fg(C.yellow, ` ✎${fileAnnots}`) : "";
+			const label = relativeFileLabel(r.repo, r.abs);
+			body = `  ${fg(selected ? C.text : C.subtext1, label)}${badge}`;
+		}
+		const full = `${prefix}${body}`;
+		const truncated = truncateToWidth(full, width, "…");
+		if (selected) return bg(C.surface0, padTo(width, truncated));
+		return padTo(width, truncated);
+	}
+
+	private renderRight(width: number, height: number): string[] {
+		const cf = this.currentFile();
+		const out: string[] = [];
+		if (!cf) {
+			out.push(padTo(width, ` ${fg(C.overlay1, "Select a file on the left to view its diff.")}`));
+			while (out.length < height) out.push(padTo(width, ""));
+			return out;
+		}
+		const head = ` ${fg(C.sapphire, bold(relativeFileLabel(cf.repo, cf.abs)))}${fg(
+			C.overlay0,
+			cf.repo ? `  —  ${repoLabel(cf.repo)}` : "",
+		)}`;
+		out.push(padTo(width, truncateToWidth(head, width, "…")));
+		out.push(padTo(width, fg(C.surface1, "─".repeat(width))));
+
+		const innerH = height - 2;
+		const r = this.getRendered(cf.abs, cf.repo, width - 1);
+		const totalRows = r.rows.length;
+		let scroll = this.getDiffScroll(cf.abs);
+		if (scroll > Math.max(0, totalRows - innerH)) {
+			scroll = Math.max(0, totalRows - innerH);
+			this.setDiffScroll(cf.abs, scroll);
+		}
+		const slice = r.rows.slice(scroll, scroll + innerH);
+		for (const ln of slice) out.push(padTo(width, ` ${ln}`));
+		while (out.length < height) out.push(padTo(width, ""));
+
+		if (totalRows > innerH) {
+			const pct = Math.min(100, Math.round(((scroll + innerH) / totalRows) * 100));
+			const tag = fg(C.overlay1, `  ${pct}% `);
+			const lastIdx = out.length - 1;
+			out[lastIdx] = padTo(width, truncateToWidth(out[lastIdx], width - visibleWidth(tag), "")) + tag;
+		}
+		return out;
+	}
+
+	private renderReview(width: number, height: number): string[] {
+		const out: string[] = [];
+		const head = ` ${fg(C.lavender, bold(`Annotations (${this.annotations.length})`))}`;
+		out.push(padTo(width, head));
+		out.push(padTo(width, fg(C.surface1, "─".repeat(width))));
+		const innerH = height - 2;
+		if (this.annotations.length === 0) {
+			out.push(padTo(width, ` ${fg(C.overlay1, "No annotations yet.")}`));
+			while (out.length < height) out.push(padTo(width, ""));
+			return out;
+		}
+		// Render up to innerH lines, paginate naively. Each annotation = 2 lines.
+		const linesPer = 3;
+		const startAnnot = Math.max(0, this.reviewSel - Math.floor(innerH / linesPer / 2));
+		let used = 0;
+		for (let i = startAnnot; i < this.annotations.length && used + linesPer <= innerH; i++) {
+			const a = this.annotations[i];
+			const isSel = i === this.reviewSel;
+			const marker = isSel ? fg(C.peach, "▌") : " ";
+			const rel = relativeFileLabel(a.repo, a.file);
+			const kindBadge =
+				a.kind === "explain"
+					? bg(C.surface1, fg(C.sapphire, " explain "))
+					: bg(C.surface1, fg(C.yellow, " fix "));
+			const head1 = `${marker} ${kindBadge} ${fg(C.sapphire, rel)} ${fg(C.overlay0, a.lineRangeLabel)}`;
+			const icon = a.kind === "explain" ? fg(C.sapphire, "?") : fg(C.yellow, "✎");
+			const head2 = `${marker} ${icon} ${fg(C.text, a.note || (a.kind === "explain" ? "(no question — just explain it)" : ""))}`;
+			const head3 = `${marker} ${fg(C.overlay1, "─".repeat(Math.max(0, width - 3)))}`;
+			const wrap = (s: string) => (isSel ? bg(C.surface0, padTo(width, truncateToWidth(s, width, "…"))) : padTo(width, truncateToWidth(s, width, "…")));
+			out.push(wrap(head1));
+			out.push(wrap(head2));
+			out.push(wrap(head3));
+			used += linesPer;
+		}
+		while (out.length < height) out.push(padTo(width, ""));
+		return out;
+	}
+}
+
+// ─── Extension entry point ───────────────────────────────────────────────────
+export default function (pi: ExtensionAPI) {
+	const touched = new Map<string, TouchedFile>();
+	// Annotations persist across overlay close so an accidental `esc` doesn't lose work.
+	const annotations: Annotation[] = [];
+
+	function record(abs: string, ts: number) {
+		const existing = touched.get(abs);
+		if (existing) {
+			existing.lastSeen = ts;
+			return;
+		}
+		touched.set(abs, { abs, repo: findRepoRoot(abs), firstSeen: ts, lastSeen: ts });
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		touched.clear();
+		const callIndex = new Map<string, { name: string; args: any; ts: number }>();
+		const entries = ctx.sessionManager.getEntries();
+		for (const entry of entries) {
+			if (entry.type !== "message") continue;
+			const msg: any = (entry as any).message;
+			if (msg?.role !== "assistant" || !Array.isArray(msg.content)) continue;
+			for (const c of msg.content) {
+				if (c && c.type === "toolCall" && typeof c.id === "string") {
+					callIndex.set(c.id, {
+						name: String(c.name ?? ""),
+						args: c.arguments ?? {},
+						ts: msg.timestamp ?? Date.now(),
+					});
+				}
+			}
+		}
+		const alreadyPersisted = new Set<string>();
+		for (const entry of entries) {
+			if (entry.type === "custom" && (entry as any).customType === ENTRY_TYPE) {
+				const data = (entry as any).data;
+				if (data?.path) {
+					record(data.path, (entry as any).timestamp ?? Date.now());
+					alreadyPersisted.add(data.path);
+				}
+			}
+		}
+		for (const entry of entries) {
+			if (entry.type !== "message") continue;
+			const msg: any = (entry as any).message;
+			if (msg?.role !== "toolResult" || msg.isError) continue;
+			const name = String(msg.toolName ?? "").toLowerCase();
+			if (name !== "edit" && name !== "write" && name !== "multiedit") continue;
+			const call = callIndex.get(msg.toolCallId);
+			const args = call?.args ?? {};
+			const rawPath: string | undefined =
+				args.path ?? args.file_path ?? args.filePath ?? args.target;
+			if (!rawPath) continue;
+			const abs = absolutize(rawPath, ctx.cwd);
+			const ts = msg.timestamp ?? call?.ts ?? Date.now();
+			const isNew = !touched.has(abs);
+			record(abs, ts);
+			if (isNew && !alreadyPersisted.has(abs)) {
+				pi.appendEntry(ENTRY_TYPE, { path: abs });
+				alreadyPersisted.add(abs);
+			}
+		}
+	});
+
+	pi.on("tool_result", async (event, ctx) => {
+		if (event.isError) return;
+		const name = (event.toolName || "").toLowerCase();
+		if (name !== "edit" && name !== "write" && name !== "multiedit") return;
+		const input: any = (event as any).input ?? {};
+		const path: string | undefined =
+			input.path ?? input.file_path ?? input.filePath ?? input.target;
+		if (!path) return;
+		const abs = absolutize(path, ctx.cwd);
+		const isNew = !touched.has(abs);
+		record(abs, Date.now());
+		if (isNew) pi.appendEntry(ENTRY_TYPE, { path: abs });
+	});
+
+	pi.registerCommand("session-diff", {
+		description: "Show files changed in this session with a diff + annotation viewer",
+		handler: async (_args, ctx: ExtensionContext) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("session-diff requires an interactive UI", "error");
+				return;
+			}
+			const files = [...touched.values()];
+			if (files.length === 0) {
+				ctx.ui.notify("No files changed in this session yet.", "info");
+				return;
+			}
+			let pendingPrompt: string | null = null;
+			await ctx.ui.custom<void>(
+				(tui, _theme, _kb, done) => {
+					const view = new SessionDiffView(files, annotations);
+					view.onClose = () => done(undefined);
+					view.onSubmit = (prompt) => {
+						pendingPrompt = prompt;
+						// Submission consumes the annotations.
+						annotations.length = 0;
+						done(undefined);
+					};
+					return {
+						render: (w) => view.render(w),
+						invalidate: () => view.invalidate(),
+						handleInput: (data) => {
+							view.handleInput(data);
+							tui.requestRender();
+						},
+					};
+				},
+				{
+					overlay: true,
+					overlayOptions: {
+						width: "90%",
+						minWidth: 80,
+						maxHeight: "85%",
+						anchor: "center",
+					},
+				},
+			);
+			if (pendingPrompt) {
+				pi.sendUserMessage(pendingPrompt);
+				ctx.ui.notify("Submitted annotations to the session.", "info");
+			}
+		},
+	});
+}