diffing 0.2.0 → 0.3.0

package/dist/cli.mjs

@@ -1,16 +1,18 @@
 #!/usr/bin/env node
-import { C as revertHunk, S as listRepoFiles, _ as getRepoRoot, a as extractPlanLines, b as gitAddFile, c as formatComments, d as getFileContent, f as getGitDiffAsync, g as getRepoName, h as getProjectStorageDir, i as writeServerLock, l as getBranchName, m as getMergeStatus, o as formatPlanReview, p as getHunkHistory, r as removeServerLock, s as sectionTitleForLine, u as getCustomGitDiffAsync, v as getTabSizeForFiles, w as isSafePath, x as isGitRepo, y as getUntrackedFilePathsAsync } from "./server-lock-CAdqFSfl.mjs";
+import { C as toSafeRelativePath, S as isSafePath, _ as getUntrackedFilePathsAsync, a as formatComments, b as listRepoFiles, c as getFileContent, d as getMergeStatus, f as getProjectStorageDir, g as getTabSizeForFiles, h as getShowDiff, i as writeServerLock, l as getGitDiffAsync, m as getRepoRoot, o as getBranchName, p as getRepoName, r as removeServerLock, s as getCustomGitDiffAsync, u as getHunkHistory, v as gitAddFile, x as revertHunk, y as isGitRepo } from "./server-lock-Dj9fG9md.mjs";
+import { n as formatPlanReview, r as sectionTitleForLine, t as extractPlanLines } from "./plan-format-f62JWFI-.mjs";
+import { execFile, execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { dirname, extname, join, resolve } from "node:path";
+import { dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "node:fs";
 import getPort from "get-port";
-import { parseArgs } from "node:util";
-import { execFileSync } from "node:child_process";
+import { parseArgs, promisify } from "node:util";
 import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { serve } from "@hono/node-server";
+import { stdout } from "node:process";
 //#region src/lib/diff-options.ts
 const DEFAULTS$1 = {
 	revisions: [],
@@ -47,7 +49,11 @@ const DEFAULTS$1 = {
 	help: false,
 	version: false,
 	includeUnstaged: true,
-	includeUntracked: true
+	includeUntracked: true,
+	tui: false,
+	gpu: false,
+	showMode: false,
+	showRevspecs: []
 };
 /**
 * All git-diff option definitions for `node:util.parseArgs`.
@@ -172,6 +178,15 @@ const DIFFING_OPTIONS = {
 		type: "boolean",
 		default: false
 	},
+	tui: {
+		type: "boolean",
+		default: false
+	},
+	gpu: {
+		type: "boolean",
+		default: false
+	},
+	"gh-pr": { type: "string" },
 	help: {
 		type: "boolean",
 		short: "h"
@@ -208,18 +223,37 @@ Output Modes:
   - Terminal mode: when output is a pipe, redirect, or non-TTY
   - Web mode:     when output is a TTY (interactive terminal)
 
-  Force a mode with --web or --terminal flags.
+  Force a mode with --web, --terminal, or --tui flags.
+  --tui is experimental and opt-in. It opens a native-Rust terminal
+  interface that mirrors the web dashboard. Falls back to git diff
+  output if the environment cannot support a TUI (piped stdin, CI,
+  missing binary).
+
+Subcommands:
+  show <revspec>...    Drop-in for 'git show'. Renders commit metadata
+                       (subject, author, date, message body) above the
+                       diff in the web UI. Accepts single commits,
+                       ranges (a..b, a...b), tags, and multiple SHAs.
+                       Use '--' to separate revspecs from pathspecs.
 
 Examples:
   diffing                        Review uncommitted changes (web UI)
   diffing --staged               Review staged changes
   diffing HEAD~3                 Review last 3 commits
   diffing main..feature          Compare branches
+  diffing show HEAD              Review a single commit's metadata + diff
+  diffing show HEAD~3..HEAD      Review the last 3 commits as a series
+  diffing show HEAD -- src/      Limit a commit review to a directory
   diffing --diff-algorithm=patience src/  Diff with patience algorithm
   diffing -U10                   Diff with 10 context lines
   diffing --word-diff=color      Word-level diff in color
   diffing -b -w                  Ignore whitespace changes
-  diffing --host 0.0.0.0         Allow other machines on the LAN to review`);
+  diffing --host 0.0.0.0         Allow other machines on the LAN to review
+  diffing --tui                  Open the experimental TUI (native Rust)
+
+Note: 'diffing <sha>' runs 'git diff <sha>' (working tree vs <sha>); it
+is not the same as 'diffing show <sha>'. Use 'show' when you want to
+review a commit's changes.`);
 }
 function printGitDiffHelp() {
 	console.log(`
@@ -463,7 +497,8 @@ function parseDiffOptions(rawArgs) {
 		}
 		for (let i = dashDashIdx + 1; i < rawArgs.length; i++) opts.pathspecs.push(rawArgs[i]);
 	} else for (const p of positionals) opts.revisions.push(p);
-	if (values.web) opts.outputMode = "web";
+	if (values.tui) opts.outputMode = "tui";
+	else if (values.web) opts.outputMode = "web";
 	else if (values.terminal) opts.outputMode = "terminal";
 	if (process.stdout.isTTY && opts.outputMode === "auto") opts.outputMode = "web";
 	else if (!process.stdout.isTTY && opts.outputMode === "auto") opts.outputMode = "terminal";
@@ -544,6 +579,21 @@ function buildGitDiffArgs(opts) {
 	}
 	return args;
 }
+/**
+* Transform a `parseDiffOptions(...)` result into a "show mode" variant:
+* moves any parsed revisions into `showRevspecs`, clears `revisions` (so the
+* existing diff-engine path does not try to `git diff` them), and sets the
+* `showMode` flag. Pathspecs and every other flag survive unchanged.
+*
+* Returns the same object for callsite ergonomics — the mutation is in-place
+* because `parseDiffOptions` always returns a fresh object.
+*/
+function intoShowMode(opts) {
+	opts.showRevspecs = opts.revisions;
+	opts.revisions = [];
+	opts.showMode = true;
+	return opts;
+}
 //#endregion
 //#region src/lib/diff-engine.ts
 const MAX_BUFFER = 50 * 1024 * 1024;
@@ -552,10 +602,11 @@ const MAX_BUFFER = 50 * 1024 * 1024;
 * or a "custom" mode (specific revisions / pathspecs).
 *
 * Custom mode is used when the user provides explicit revisions or pathspecs
-* beyond just toggling staged/untracked.
+* beyond just toggling staged/untracked. `showMode` is *also* a custom mode
+* — the "Show staged / Show untracked" toggles don't apply to a commit view.
 */
 function isCustomMode$1(opts) {
-	return opts.revisions.length > 0 || opts.pathspecs.length > 0;
+	return opts.revisions.length > 0 || opts.pathspecs.length > 0 || opts.showMode;
 }
 function parseFilePaths(patch) {
 	const paths = /* @__PURE__ */ new Set();
@@ -602,8 +653,24 @@ function parseBinaryFiles(patch, untrackedFiles) {
 }
 /**
 * Execute a diff asynchronously — used by the server.
+*
+* Show mode bypasses the normal `git diff` path entirely: it resolves
+* revspecs to a commit list and fetches per-commit metadata + patches in
+* one `git log` call. The concatenated patch is returned in the same shape
+* the existing UI pipeline expects (so file tree, binary detection, and
+* tab-size detection all keep working unchanged); the per-commit data
+* rides along on `commits` for the metadata banners.
 */
 async function executeDiffAsync(opts) {
+	if (opts.showMode) {
+		const { commits, patch, truncated } = await getShowDiff(opts.showRevspecs, opts.pathspecs);
+		return {
+			patch,
+			args: [],
+			commits,
+			truncated
+		};
+	}
 	if (isCustomMode$1(opts)) {
 		const args = buildGitDiffArgs(opts);
 		return {
@@ -623,10 +690,10 @@ async function executeDiffAsync(opts) {
 * Execute a diff and produce the full enriched result used by the web API.
 */
 async function executeDiffWithMeta(opts) {
-	const { patch } = await executeDiffAsync(opts);
+	const { patch, commits, truncated } = await executeDiffAsync(opts);
 	const repoName = getRepoName();
 	const branch = getBranchName();
-	const untrackedFiles = opts.includeUntracked ? await getUntrackedFilePathsAsync() : [];
+	const untrackedFiles = opts.includeUntracked && !opts.showMode ? await getUntrackedFilePathsAsync() : [];
 	const binaryFiles = parseBinaryFiles(patch, new Set(untrackedFiles));
 	const filePaths = parseFilePaths(patch);
 	return {
@@ -636,14 +703,19 @@ async function executeDiffWithMeta(opts) {
 		tabSizeMap: getTabSizeForFiles(filePaths),
 		untrackedFiles,
 		repoName,
-		branch
+		branch,
+		...commits ? { commits } : {},
+		...truncated ? { truncated } : {}
 	};
 }
 /**
 * Run the diff in terminal mode: forward to git diff with full flags,
-* output to stdout. Behaves identically to `git diff`.
+* output to stdout. Behaves identically to `git diff`. In show mode this
+* delegates to `git show` instead so `diffing show <rev>... --terminal`
+* is a drop-in for `git show <rev>...`.
 */
 function runTerminalDiff(opts) {
+	if (opts.showMode) return runTerminalShow(opts);
 	const args = buildGitDiffArgs(opts);
 	const enforceDefaults = !opts.outputFormat && !opts.quiet;
 	const finalArgs = [];
@@ -664,6 +736,30 @@ function runTerminalDiff(opts) {
 	}
 }
 /**
+* Terminal mode for `diffing show`: spawn `git show` with the user's revspecs
+* and pathspecs, inherit stdio, propagate exit code. We pass `--no-ext-diff`
+* so the output is a clean unified diff regardless of the user's git config
+* (matches the web-mode pipeline), but otherwise hand everything to git.
+*/
+function runTerminalShow(opts) {
+	const args = [
+		"show",
+		"--no-ext-diff",
+		...opts.showRevspecs
+	];
+	if (opts.pathspecs.length > 0) args.push("--", ...opts.pathspecs);
+	try {
+		execFileSync("git", args, {
+			encoding: "utf-8",
+			maxBuffer: MAX_BUFFER,
+			stdio: "inherit"
+		});
+		return 0;
+	} catch (err) {
+		return err.status ?? 1;
+	}
+}
+/**
 * Validate the environment: check that we're in a git repo.
 * Returns an error message or null.
 */
@@ -1112,7 +1208,10 @@ const DEFAULTS = {
 	expandContextByDefault: false,
 	collapsedContextThreshold: 10,
 	expansionLineCount: 20,
-	haptics: true
+	haptics: true,
+	sounds: true,
+	uiFont: null,
+	monoFont: null
 };
 function loadSettings() {
 	try {
@@ -1139,9 +1238,15 @@ function saveSettings(settings) {
 var FileCommentStore = class {
 	dirPath;
 	filePath;
-	constructor(customRepoRoot) {
-		if (customRepoRoot) this.dirPath = join(customRepoRoot, ".diffing");
-		else this.dirPath = getProjectStorageDir();
+	/**
+	* @param storageDir Absolute directory to persist `comments.json` in.
+	*   Defaults to the per-repo storage dir under `~/.diffing` — comments are
+	*   NEVER written inside the reviewed (consumer) repo, so a consumer project
+	*   stays free of any diffing-specific artifacts. The override exists only so
+	*   tests can point at a throwaway temp dir.
+	*/
+	constructor(storageDir) {
+		this.dirPath = storageDir ?? getProjectStorageDir();
 		this.filePath = join(this.dirPath, "comments.json");
 	}
 	async getAll() {
@@ -1261,9 +1366,15 @@ function applyUpsert(plans, input, now) {
 var FilePlanStore = class {
 	dirPath;
 	filePath;
-	constructor(customRepoRoot) {
-		if (customRepoRoot) this.dirPath = join(customRepoRoot, ".diffing");
-		else this.dirPath = getProjectStorageDir();
+	/**
+	* @param storageDir Absolute directory to persist `plans.json` in. Defaults
+	*   to the per-repo storage dir under `~/.diffing`, the same place comments
+	*   and media live — plans are NEVER written inside the reviewed (consumer)
+	*   repo, so a consumer project stays free of any diffing-specific artifacts.
+	*   The override exists only so tests can point at a throwaway temp dir.
+	*/
+	constructor(storageDir) {
+		this.dirPath = storageDir ?? getProjectStorageDir();
 		this.filePath = join(this.dirPath, "plans.json");
 	}
 	async getAll() {
@@ -1389,6 +1500,95 @@ var FilePlanStore = class {
 	}
 };
 //#endregion
+//#region src/lib/state.ts
+var FileUiStateStore = class {
+	dirPath;
+	filePath;
+	constructor(storageDir) {
+		this.dirPath = storageDir ?? getProjectStorageDir();
+		this.filePath = join(this.dirPath, "ui-state.json");
+	}
+	async getAll() {
+		try {
+			const data = await readFile(this.filePath, "utf-8");
+			return JSON.parse(data);
+		} catch {
+			return {};
+		}
+	}
+	async setAll(state) {
+		await this.save(state);
+	}
+	async save(state) {
+		try {
+			await mkdir(this.dirPath, { recursive: true });
+			try {
+				const repoRoot = getRepoRoot();
+				await writeFile(join(this.dirPath, "repo_path.txt"), repoRoot, "utf-8");
+			} catch {}
+			await writeFile(this.filePath, JSON.stringify(state, null, 2), "utf-8");
+		} catch (err) {
+			console.error("Failed to save UI state to file:", err);
+		}
+	}
+};
+//#endregion
+//#region src/lib/editor-launcher.ts
+function resolveEditorCommand(editor, absolutePath, platform = process.platform, env = process.env) {
+	switch (editor) {
+		case "vscode": return guiEditorCommand("code", absolutePath, platform);
+		case "zed": return guiEditorCommand("zed", absolutePath, platform);
+		case "vim": return terminalEditorCommand("vim", absolutePath, platform, env);
+		case "neovim": return terminalEditorCommand("nvim", absolutePath, platform, env);
+		default: return null;
+	}
+}
+function guiEditorCommand(bin, absolutePath, platform) {
+	if (platform === "win32") return {
+		cmd: `${bin}.cmd`,
+		args: [absolutePath]
+	};
+	return {
+		cmd: bin,
+		args: [absolutePath]
+	};
+}
+function terminalEditorCommand(bin, absolutePath, platform, env) {
+	if (platform === "darwin") return {
+		cmd: "osascript",
+		args: ["-e", `tell application "Terminal" to do script "${bin} \\"${absolutePath.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}\\""`]
+	};
+	if (platform === "win32") return {
+		cmd: "cmd.exe",
+		args: [
+			"/c",
+			"start",
+			"\"\"",
+			"cmd.exe",
+			"/k",
+			bin,
+			absolutePath
+		]
+	};
+	const term = env.TERMINAL?.trim();
+	if (term) return {
+		cmd: term,
+		args: [
+			"-e",
+			bin,
+			absolutePath
+		]
+	};
+	return {
+		cmd: "x-terminal-emulator",
+		args: [
+			"-e",
+			bin,
+			absolutePath
+		]
+	};
+}
+//#endregion
 //#region src/lib/review-session.ts
 var ReviewSession = class {
 	round = 0;
@@ -1452,7 +1652,8 @@ var ReviewSession = class {
 			sentAt: input.sentAt,
 			commentXml: input.commentXml,
 			openCount: input.openCount,
-			comments: input.comments
+			comments: input.comments,
+			decision: input.decision
 		};
 		this.lastPayload = payload;
 		const waiters = [...this.waiters];
@@ -1580,6 +1781,483 @@ var PlanReviewSession = class {
 	}
 };
 //#endregion
+//#region src/lib/pr-session.ts
+var FilePrSessionStore = class {
+	dirPath;
+	filePath;
+	constructor(storageDir) {
+		this.dirPath = storageDir ?? getProjectStorageDir();
+		this.filePath = join(this.dirPath, "pr-session.json");
+	}
+	async get() {
+		try {
+			const data = await readFile(this.filePath, "utf-8");
+			return JSON.parse(data);
+		} catch {
+			return null;
+		}
+	}
+	async save(session) {
+		try {
+			await mkdir(this.dirPath, { recursive: true });
+			await writeFile(this.filePath, JSON.stringify(session, null, 2), "utf-8");
+		} catch (err) {
+			console.error("Failed to save pr-session to file:", err);
+		}
+	}
+	async set(session) {
+		await this.save(session);
+	}
+	async update(fields) {
+		const current = await this.get();
+		if (!current) return null;
+		const next = {
+			...current,
+			...fields
+		};
+		await this.save(next);
+		return next;
+	}
+	async clear() {
+		try {
+			const { unlink } = await import("node:fs/promises");
+			await unlink(this.filePath);
+		} catch {}
+	}
+};
+//#endregion
+//#region src/lib/github.ts
+const execFileAsync = promisify(execFile);
+/**
+* Probe the `gh` CLI: is it on `$PATH`, and is the user authenticated?
+* Never throws — returns a permissive `available: false` on any failure.
+*/
+async function detectGhCli() {
+	try {
+		const { stdout } = await execFileAsync("gh", ["--version"], { encoding: "utf-8" });
+		const version = stdout.split("\n")[0]?.trim() || void 0;
+		try {
+			const result = await execFileAsync("gh", ["auth", "status"], { encoding: "utf-8" });
+			return {
+				available: true,
+				authenticated: true,
+				version,
+				user: parseGhAuthStatusUser(`${result.stdout ?? ""}\n${result.stderr ?? ""}`)
+			};
+		} catch {
+			return {
+				available: true,
+				authenticated: false,
+				version
+			};
+		}
+	} catch {
+		return {
+			available: false,
+			authenticated: false
+		};
+	}
+}
+/**
+* Extract the GitHub username from `gh auth status` output. Exported for
+* unit tests — see `__tests__/github-auth.test.ts`.
+*
+* Real-world samples:
+*   `✓ Logged in to github.com account octocat (keyring)`        (gh 2.40+)
+*   `Logged in to github.com as octocat (oauth_token)`            (older gh)
+*   `  ✓ Logged in to github.com as octocat (~/.config/gh/hosts.yml)`
+*/
+function parseGhAuthStatusUser(output) {
+	const account = /Logged in to [^\s]+ account\s+([^\s(]+)/.exec(output);
+	if (account) return account[1];
+	return /Logged in to [^\s]+ as\s+([^\s(]+)/.exec(output)?.[1];
+}
+/** Read the most-preferred GitHub token from the env. */
+function readGithubToken() {
+	const env = process.env;
+	return env.GH_TOKEN || env.GITHUB_TOKEN || env.GITHUB_API_TOKEN || null;
+}
+function parsePrRef(input, cwdRepo) {
+	const trimmed = input.trim();
+	const urlMatch = /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/i.exec(trimmed);
+	if (urlMatch) return {
+		owner: urlMatch[1],
+		repo: urlMatch[2],
+		pullNumber: Number(urlMatch[3]),
+		ref: trimmed
+	};
+	const shorthand = /^([^/\s]+)\/([^#\s]+)#(\d+)$/.exec(trimmed);
+	if (shorthand) return {
+		owner: shorthand[1],
+		repo: shorthand[2],
+		pullNumber: Number(shorthand[3]),
+		ref: trimmed
+	};
+	const bare = /^#?(\d+)$/.exec(trimmed);
+	if (bare && cwdRepo) return {
+		owner: cwdRepo.owner,
+		repo: cwdRepo.repo,
+		pullNumber: Number(bare[1]),
+		ref: trimmed
+	};
+	if (bare) throw new Error(`Cannot resolve bare PR number "${trimmed}" — run from inside the target repo, or pass a full URL or \`owner/repo#1234\`.`);
+	throw new Error(`Unrecognised PR ref: ${trimmed}`);
+}
+/**
+* Best-effort: derive `{ owner, repo }` for the current working directory
+* from `git remote get-url origin`. Falls back to throwing.
+*/
+async function detectCwdRepo() {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"remote",
+			"get-url",
+			"origin"
+		], { encoding: "utf-8" });
+		const url = stdout.trim();
+		const m = /github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?\s*$/.exec(url);
+		if (m) return {
+			owner: m[1],
+			repo: m[2]
+		};
+	} catch {}
+	return null;
+}
+/**
+* Fetch PR metadata + diff + existing review comments using `gh`.
+* Throws with a user-readable message on failure.
+*/
+async function fetchPrMetadataViaGh(resolved) {
+	const args = ["-R", `${resolved.owner}/${resolved.repo}`];
+	let metaJson;
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"pr",
+			"view",
+			String(resolved.pullNumber),
+			...args,
+			"--json",
+			"number,title,url,author,baseRefOid,headRefOid,additions,deletions,changedFiles,headRepositoryOwner,headRepository"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 20 * 1024 * 1024
+		});
+		metaJson = JSON.parse(stdout);
+	} catch (err) {
+		const stderr = err?.stderr || err?.message || "unknown error";
+		throw new Error(`gh pr view failed: ${stderr.trim()}`);
+	}
+	let diff = "";
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"pr",
+			"diff",
+			String(resolved.pullNumber),
+			...args
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		diff = stdout;
+	} catch (err) {
+		const stderr = err?.stderr || err?.message || "unknown error";
+		throw new Error(`gh pr diff failed: ${stderr.trim()}`);
+	}
+	const headOwner = metaJson.headRepositoryOwner?.login || metaJson.headRepository?.owner?.login || resolved.owner;
+	const repoName = metaJson.headRepository?.name || resolved.repo;
+	const author = metaJson.author ? {
+		login: metaJson.author.login,
+		avatarUrl: metaJson.author.avatarUrl
+	} : null;
+	const existingComments = await fetchExistingCommentsViaGh(resolved);
+	return {
+		number: metaJson.number,
+		title: metaJson.title,
+		url: metaJson.url,
+		author,
+		baseSha: metaJson.baseRefOid,
+		headSha: metaJson.headRefOid,
+		additions: metaJson.additions,
+		deletions: metaJson.deletions,
+		changedFiles: metaJson.changedFiles,
+		owner: headOwner,
+		repo: repoName,
+		diff,
+		existingComments
+	};
+}
+async function fetchExistingCommentsViaGh(resolved) {
+	`${resolved.owner}${resolved.repo}`;
+	const endpoint = `repos/${resolved.owner}/${resolved.repo}/pulls/${resolved.pullNumber}/comments`;
+	const reviewsEndpoint = `repos/${resolved.owner}/${resolved.repo}/pulls/${resolved.pullNumber}/reviews`;
+	let reviews = [];
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"api",
+			reviewsEndpoint,
+			"--paginate"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 20 * 1024 * 1024
+		});
+		const all = JSON.parse(stdout);
+		if (Array.isArray(all)) reviews = all;
+	} catch {}
+	reviews.sort((a, b) => a.submitted_at < b.submitted_at ? 1 : -1);
+	const recentReviews = reviews.slice(0, 50);
+	const reviewStateById = /* @__PURE__ */ new Map();
+	for (const r of recentReviews) reviewStateById.set(r.id, r.state);
+	let commentsRaw = [];
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"api",
+			`${endpoint}?per_page=100`,
+			"--paginate"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 20 * 1024 * 1024
+		});
+		const parsed = JSON.parse(stdout);
+		if (Array.isArray(parsed)) commentsRaw = parsed;
+	} catch {
+		return [];
+	}
+	const byId = /* @__PURE__ */ new Map();
+	for (const c of commentsRaw) byId.set(c.id, c);
+	const replyByParent = /* @__PURE__ */ new Map();
+	for (const c of commentsRaw) if (c.in_reply_to_id && byId.has(c.in_reply_to_id)) {
+		const list = replyByParent.get(c.in_reply_to_id) ?? [];
+		list.push(c);
+		replyByParent.set(c.in_reply_to_id, list);
+	}
+	const tops = [];
+	for (const c of commentsRaw) {
+		if (c.in_reply_to_id) continue;
+		const state = c.pull_request_review_id ? reviewStateById.get(c.pull_request_review_id) ?? null : null;
+		tops.push({
+			id: c.id,
+			author: c.user ? {
+				login: c.user.login,
+				avatarUrl: c.user.avatar_url
+			} : null,
+			body: c.body ?? "",
+			path: c.path,
+			line: typeof c.line === "number" ? c.line : null,
+			side: c.side === "LEFT" || c.side === "RIGHT" ? c.side : null,
+			createdAt: c.created_at,
+			updatedAt: c.updated_at,
+			state,
+			replies: (replyByParent.get(c.id) ?? []).map((r) => ({
+				id: r.id,
+				author: r.user ? {
+					login: r.user.login,
+					avatarUrl: r.user.avatar_url
+				} : null,
+				body: r.body ?? "",
+				createdAt: r.created_at,
+				updatedAt: r.updated_at
+			})),
+			isOutdated: typeof c.position === "number" && c.position === null ? false : false
+		});
+	}
+	tops.sort((a, b) => {
+		if (a.path !== b.path) return a.path.localeCompare(b.path);
+		return (a.line ?? 0) - (b.line ?? 0);
+	});
+	return tops;
+}
+/**
+* POST the review to GitHub. Prefers `gh api` (uses the user's existing
+* `gh auth`); falls back to a direct HTTP call with `$GITHUB_TOKEN` when
+* `gh` is unavailable.
+*/
+async function submitReview(input) {
+	const gh = await detectGhCli();
+	if (gh.available && gh.authenticated) return submitViaGh(input);
+	const token = readGithubToken();
+	if (token) return submitViaToken(input, token);
+	return {
+		ok: false,
+		authSource: "none",
+		error: "Cannot submit: no `gh` CLI on $PATH (or not authenticated) and no $GITHUB_TOKEN env var. Run `gh auth login` or set $GITHUB_TOKEN."
+	};
+}
+/**
+* Map our `PrDecision` to the GitHub REST event string. Exported so the
+* test suite can pin the mapping (including the `rejected → REQUEST_CHANGES`
+* quirk, which exists because GitHub has no REJECT event).
+*/
+function decisionToEvent(decision) {
+	if (decision === "approve") return "APPROVE";
+	if (decision === "request-changes") return "REQUEST_CHANGES";
+	return "COMMENT";
+}
+/**
+* Expand multi-line `ReviewComment`s into N single-line `gh`-shaped entries
+* with `[part N/M]` prefixes. Exported for the test suite — the body of the
+* caller (`buildReviewPayload`) is otherwise private.
+*
+* Skips: non-`open` comments, file-level comments (`lineNumber === 0`).
+* Strips the `a/` / `b/` prefix from the file path (GitHub expects PR-relative
+* paths in the `path` field).
+*/
+function expandMultiLineComments(comments) {
+	const flat = [];
+	for (const c of comments) {
+		if (c.status !== "open") continue;
+		if (c.lineNumber === 0) continue;
+		const path = stripBPrefix(c.filePath);
+		const start = c.startLineNumber && c.startLineNumber < c.lineNumber ? c.startLineNumber : c.lineNumber;
+		const end = c.lineNumber;
+		const span = end - start + 1;
+		if (span > 1) for (let i = 0; i < span; i++) flat.push({
+			path,
+			line: start + i,
+			side: "RIGHT",
+			body: `[part ${i + 1}/${span}]\n${c.body}`
+		});
+		else flat.push({
+			path,
+			line: end,
+			side: "RIGHT",
+			body: c.body
+		});
+	}
+	return flat;
+}
+function buildReviewPayload(input) {
+	return {
+		body: input.body,
+		event: decisionToEvent(input.decision ?? "comment"),
+		comments: expandMultiLineComments(input.comments ?? [])
+	};
+}
+function stripBPrefix(path) {
+	if (path.startsWith("b/")) return path.slice(2);
+	if (path.startsWith("a/")) return path.slice(2);
+	return path;
+}
+async function submitViaGh(input) {
+	const payload = buildReviewPayload(input);
+	`${input.resolved.owner}${input.resolved.repo}`;
+	const args = [
+		"api",
+		"--method",
+		"POST",
+		`repos/${input.resolved.owner}/${input.resolved.repo}/pulls/${input.resolved.pullNumber}/reviews`,
+		"-H",
+		"Accept: application/vnd.github+json",
+		"--input",
+		"-"
+	];
+	try {
+		const { stdout } = await execFileAsync("gh", args, {
+			encoding: "utf-8",
+			maxBuffer: 20 * 1024 * 1024,
+			input: JSON.stringify(payload)
+		});
+		const result = JSON.parse(stdout);
+		return {
+			ok: true,
+			authSource: "gh",
+			reviewId: result.id,
+			reviewUrl: result.html_url
+		};
+	} catch (err) {
+		const stdout = err?.stdout || "";
+		const stderr = err?.stderr || err?.message || "unknown error";
+		let parsed = null;
+		try {
+			parsed = JSON.parse(stdout);
+		} catch {}
+		return {
+			ok: false,
+			authSource: "gh",
+			error: parsed?.message || stderr.trim()
+		};
+	}
+}
+async function submitViaToken(input, token) {
+	const payload = buildReviewPayload(input);
+	const url = `https://api.github.com/repos/${input.resolved.owner}/${input.resolved.repo}/pulls/${input.resolved.pullNumber}/reviews`;
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				Accept: "application/vnd.github+json",
+				"X-GitHub-Api-Version": "2022-11-28",
+				"Content-Type": "application/json",
+				"User-Agent": "diffing-cli"
+			},
+			body: JSON.stringify(payload)
+		});
+		if (!res.ok) {
+			const errBody = await res.text().catch(() => "");
+			return {
+				ok: false,
+				authSource: "token",
+				error: `HTTP ${res.status}: ${errBody.slice(0, 500)}`
+			};
+		}
+		const result = await res.json();
+		return {
+			ok: true,
+			authSource: "token",
+			reviewId: result.id,
+			reviewUrl: result.html_url
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			authSource: "token",
+			error: err?.message || "Network error"
+		};
+	}
+}
+async function buildPrSession(ref) {
+	const meta = await fetchPrMetadataViaGh(parsePrRef(ref, await detectCwdRepo() ?? void 0));
+	return {
+		ref,
+		owner: meta.owner,
+		repo: meta.repo,
+		pullNumber: meta.number,
+		baseSha: meta.baseSha,
+		headSha: meta.headSha,
+		title: meta.title,
+		url: meta.url,
+		author: meta.author,
+		additions: meta.additions,
+		deletions: meta.deletions,
+		changedFiles: meta.changedFiles,
+		diff: meta.diff,
+		comments: [],
+		existingComments: meta.existingComments
+	};
+}
+/** Refresh `diff` + `existingComments` + head SHA in an existing session. */
+async function refreshPrSession(session) {
+	const meta = await fetchPrMetadataViaGh({
+		owner: session.owner,
+		repo: session.repo,
+		pullNumber: session.pullNumber,
+		ref: session.ref
+	});
+	return {
+		...session,
+		baseSha: meta.baseSha,
+		headSha: meta.headSha,
+		title: meta.title,
+		url: meta.url,
+		author: meta.author,
+		additions: meta.additions,
+		deletions: meta.deletions,
+		changedFiles: meta.changedFiles,
+		diff: meta.diff,
+		existingComments: meta.existingComments
+	};
+}
+//#endregion
 //#region src/server.ts
 const MIME_TYPES = {
 	".html": "text/html",
@@ -1597,13 +2275,15 @@ const MIME_TYPES = {
 	".avif": "image/avif"
 };
 function isCustomMode(opts) {
-	return opts.revisions.length > 0 || opts.pathspecs.length > 0;
+	return opts.revisions.length > 0 || opts.pathspecs.length > 0 || opts.showMode;
 }
-function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
+function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore, prSessionStore) {
 	const app = new Hono();
 	const customMode = isCustomMode(diffOpts);
 	const store = commentStore ?? new FileCommentStore();
 	const plans = planStore ?? new FilePlanStore();
+	const prStore = prSessionStore ?? new FilePrSessionStore();
+	const uiStateStore = new FileUiStateStore();
 	const viewedFiles = /* @__PURE__ */ new Set();
 	const activeClients = /* @__PURE__ */ new Set();
 	const broadcast = (event, data) => {
@@ -1624,6 +2304,7 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		mkdirSync(storageDir, { recursive: true });
 		let commentsDebounce = null;
 		let plansDebounce = null;
+		let prSessionDebounce = null;
 		watch(storageDir, (_eventType, filename) => {
 			if (!filename) return;
 			if (filename.startsWith("comments.json")) {
@@ -1632,6 +2313,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 			} else if (filename.startsWith("plans.json")) {
 				if (plansDebounce) clearTimeout(plansDebounce);
 				plansDebounce = setTimeout(() => broadcast("plans", Date.now().toString()), 120);
+			} else if (filename.startsWith("pr-session.json")) {
+				if (prSessionDebounce) clearTimeout(prSessionDebounce);
+				prSessionDebounce = setTimeout(() => broadcast("pr-session", Date.now().toString()), 120);
 			}
 		}).unref();
 	} catch (err) {
@@ -1692,11 +2376,40 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 	app.get("/api/diff", async (c) => {
 		const staged = c.req.query("staged") === "true";
 		const untracked = c.req.query("untracked") === "true";
-		const result = await executeDiffWithMeta(customMode ? diffOpts : {
+		const prSession = await prStore.get();
+		if (prSession) {
+			const binaryFiles = [];
+			const filePaths = [];
+			for (const line of prSession.diff.split("\n")) {
+				const m = /^diff --git a\/.+ b\/(.+)$/.exec(line);
+				if (m) filePaths.push(m[1]);
+			}
+			return c.json({
+				patch: prSession.diff,
+				repoName: prSession.repo,
+				branch: `#${prSession.pullNumber}`,
+				customMode: true,
+				binaryFiles,
+				tabSizeMap: {},
+				untrackedFiles: [],
+				prMode: true,
+				prRef: prSession.ref,
+				prOwner: prSession.owner,
+				prRepo: prSession.repo,
+				prPullNumber: prSession.pullNumber,
+				prUrl: prSession.url,
+				prTitle: prSession.title,
+				prAuthor: prSession.author,
+				prHeadSha: prSession.headSha,
+				prBaseSha: prSession.baseSha
+			});
+		}
+		const optsForDiff = customMode ? diffOpts : {
 			...diffOpts,
 			staged,
 			includeUntracked: untracked
-		});
+		};
+		const result = await executeDiffWithMeta(optsForDiff);
 		return c.json({
 			patch: result.patch,
 			repoName: result.repoName,
@@ -1704,7 +2417,10 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 			customMode,
 			binaryFiles: result.binaryFiles,
 			tabSizeMap: result.tabSizeMap,
-			untrackedFiles: result.untrackedFiles
+			untrackedFiles: result.untrackedFiles,
+			showMode: optsForDiff.showMode || void 0,
+			commits: result.commits,
+			truncated: result.truncated
 		});
 	});
 	app.get("/api/file-content", (c) => {
@@ -1737,14 +2453,20 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		if (!filePath) return c.json({ error: "filePath is required" }, 400);
 		try {
 			const root = getRepoRoot();
-			if (!isSafePath(filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
-			const absolutePath = resolve(root, filePath);
-			const { exec } = await import("node:child_process");
-			if (editor === "vscode") exec(`code "${absolutePath}"`);
-			else if (editor === "zed") exec(`zed "${absolutePath}"`);
-			else if (editor === "vim") exec(`osascript -e 'tell application "Terminal" to do script "vim \\"${absolutePath}\\""'`);
-			else if (editor === "neovim") exec(`osascript -e 'tell application "Terminal" to do script "nvim \\"${absolutePath}\\""'`);
-			else await (await import("open")).default(absolutePath);
+			const relPath = toSafeRelativePath(filePath, root);
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			const absolutePath = resolve(root, relPath);
+			if (editor && editor !== "default") {
+				const command = resolveEditorCommand(editor, absolutePath);
+				if (command) {
+					const { execFile } = await import("node:child_process");
+					execFile(command.cmd, command.args, (err) => {
+						if (err) console.error(`Failed to launch ${editor} for ${absolutePath}: ${err.message}`);
+					});
+					return c.json({ ok: true });
+				}
+			}
+			await (await import("open")).default(absolutePath);
 			return c.json({ ok: true });
 		} catch (err) {
 			return c.json({ error: `Failed to open file: ${err.message}` }, 500);
@@ -1812,8 +2534,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		const { filePath, hunkIndex } = await c.req.json();
 		if (!filePath || typeof hunkIndex !== "number") return c.json({ error: "Missing filePath or hunkIndex" }, 400);
 		try {
-			if (!isSafePath(filePath, getRepoRoot())) return c.json({ error: "Forbidden file path" }, 403);
-			revertHunk(filePath, hunkIndex);
+			const relPath = toSafeRelativePath(filePath, getRepoRoot());
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			revertHunk(relPath, hunkIndex);
 			return c.json({ ok: true });
 		} catch (err) {
 			const stderr = typeof err?.stderr === "string" ? err.stderr : err?.stderr instanceof Buffer ? err.stderr.toString("utf-8") : "";
@@ -1826,8 +2549,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		const deletionCount = Number(c.req.query("deletionCount"));
 		if (!filePath || Number.isNaN(deletionStart) || Number.isNaN(deletionCount)) return c.json({ error: "Missing or invalid parameters" }, 400);
 		try {
-			if (!isSafePath(filePath, getRepoRoot())) return c.json({ error: "Forbidden file path" }, 403);
-			const history = getHunkHistory(filePath, deletionStart, deletionCount, diffOpts.revisions[0] || "HEAD");
+			const relPath = toSafeRelativePath(filePath, getRepoRoot());
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			const history = getHunkHistory(relPath, deletionStart, deletionCount, diffOpts.showMode ? diffOpts.showRevspecs[diffOpts.showRevspecs.length - 1] || "HEAD" : diffOpts.revisions[0] || "HEAD");
 			return c.json(history);
 		} catch (err) {
 			return c.json({ error: err.message || "Failed to fetch hunk history" }, 500);
@@ -1838,10 +2562,11 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		if (!filePath || typeof content !== "string") return c.json({ error: "Missing filePath or content" }, 400);
 		try {
 			const root = getRepoRoot();
-			if (!isSafePath(filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
-			await writeFile(resolve(root, filePath), content, "utf-8");
+			const relPath = toSafeRelativePath(filePath, root);
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			await writeFile(resolve(root, relPath), content, "utf-8");
 			if (gitAdd) try {
-				gitAddFile(filePath);
+				gitAddFile(relPath);
 			} catch (err) {
 				return c.json({
 					ok: true,
@@ -1860,6 +2585,19 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		const settings = saveSettings(await c.req.json());
 		return c.json(settings);
 	});
+	app.get("/api/ui-state", async (c) => {
+		return c.json(await uiStateStore.getAll());
+	});
+	app.put("/api/ui-state", async (c) => {
+		const body = await c.req.json();
+		const merged = {
+			...await uiStateStore.getAll(),
+			...body
+		};
+		for (const key of Object.keys(body)) if (body[key] === null || body[key] === void 0) delete merged[key];
+		await uiStateStore.setAll(merged);
+		return c.json(merged);
+	});
 	app.get("/api/viewed", (c) => {
 		return c.json([...viewedFiles]);
 	});
@@ -1940,8 +2678,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		const suggestion = match[1];
 		try {
 			const root = getRepoRoot();
-			if (!isSafePath(comment.filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
-			const absolutePath = resolve(root, comment.filePath);
+			const relPath = toSafeRelativePath(comment.filePath, root);
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			const absolutePath = resolve(root, relPath);
 			const lines = (await readFile(absolutePath, "utf-8")).split(/\r?\n/);
 			const lineIdx = comment.lineNumber - 1;
 			if (lineIdx < 0 || lineIdx >= lines.length) return c.json({ error: "Comment line number out of range" }, 400);
@@ -1958,21 +2697,211 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		if (!await store.remove(id)) return c.json({ error: "Comment not found" }, 404);
 		return c.json({ ok: true });
 	});
+	/** Shared helper: 404 with a stable shape so the client knows "not in PR mode". */
+	const notInPrMode = (c) => c.json({
+		error: "Not in PR review mode",
+		prMode: false
+	}, 404);
+	app.get("/api/gh/session", async (c) => {
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		return c.json({
+			prMode: true,
+			ref: session.ref,
+			owner: session.owner,
+			repo: session.repo,
+			pullNumber: session.pullNumber,
+			baseSha: session.baseSha,
+			headSha: session.headSha,
+			title: session.title,
+			url: session.url,
+			author: session.author,
+			additions: session.additions,
+			deletions: session.deletions,
+			changedFiles: session.changedFiles,
+			existingComments: session.existingComments,
+			submittedAt: session.submittedAt,
+			submittedReviewId: session.submittedReviewId,
+			submittedReviewUrl: session.submittedReviewUrl,
+			authSource: session.authSource
+		});
+	});
+	/** Re-fetch PR metadata (head SHA, diff, existing comments) and persist. */
+	app.post("/api/gh/pr/refresh", async (c) => {
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		try {
+			const refreshed = await refreshPrSession(session);
+			await prStore.set(refreshed);
+			return c.json({
+				ok: true,
+				headSha: refreshed.headSha
+			});
+		} catch (err) {
+			return c.json({ error: err?.message ?? "Refresh failed" }, 500);
+		}
+	});
+	/** Initialize a PR session from a ref like `1234`, `o/r#42`, or a GitHub URL. */
+	app.post("/api/gh/pr/init", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const ref = typeof body?.ref === "string" ? body.ref : "";
+		if (!ref.trim()) return c.json({ error: "ref is required" }, 400);
+		try {
+			parsePrRef(ref, await detectCwdRepo() ?? void 0);
+			const session = await buildPrSession(ref);
+			await prStore.set(session);
+			return c.json({
+				ok: true,
+				ref: session.ref,
+				owner: session.owner,
+				repo: session.repo,
+				pullNumber: session.pullNumber,
+				url: session.url
+			});
+		} catch (err) {
+			return c.json({ error: err?.message ?? "Failed to initialise PR session" }, 500);
+		}
+	});
+	app.get("/api/gh/pr-session/comments", async (c) => {
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		return c.json(session.comments ?? []);
+	});
+	app.post("/api/gh/pr-session/comments", async (c) => {
+		const body = await c.req.json();
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const comment = {
+			id: crypto.randomUUID(),
+			filePath: body.filePath,
+			side: body.side,
+			lineNumber: body.lineNumber,
+			startLineNumber: body.startLineNumber,
+			lineContent: body.lineContent,
+			body: body.body,
+			status: "open",
+			createdAt: Date.now(),
+			replies: []
+		};
+		const next = {
+			...session,
+			comments: [...session.comments ?? [], comment]
+		};
+		await prStore.set(next);
+		return c.json(comment, 201);
+	});
+	app.put("/api/gh/pr-session/comments/:id", async (c) => {
+		const id = c.req.param("id");
+		const { body, status } = await c.req.json();
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const comments = (session.comments ?? []).map((cm) => cm.id === id ? {
+			...cm,
+			body: body ?? cm.body,
+			status: status ?? cm.status
+		} : cm);
+		await prStore.set({
+			...session,
+			comments
+		});
+		const updated = comments.find((cm) => cm.id === id) ?? null;
+		if (!updated) return c.json({ error: "Comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/gh/pr-session/comments/:id", async (c) => {
+		const id = c.req.param("id");
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const comments = (session.comments ?? []).filter((cm) => cm.id !== id);
+		await prStore.set({
+			...session,
+			comments
+		});
+		return c.json({ ok: true });
+	});
+	app.post("/api/gh/pr-session/comments/:id/replies", async (c) => {
+		const id = c.req.param("id");
+		const { body, role, model } = await c.req.json();
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const comments = (session.comments ?? []).map((cm) => {
+			if (cm.id !== id) return cm;
+			const reply = {
+				id: crypto.randomUUID(),
+				body,
+				createdAt: Date.now(),
+				role: role || (model ? "agent" : "user"),
+				model: model || void 0
+			};
+			return {
+				...cm,
+				replies: [...cm.replies ?? [], reply]
+			};
+		});
+		await prStore.set({
+			...session,
+			comments
+		});
+		return c.json(comments.find((cm) => cm.id === id));
+	});
+	/** Submit the current PR session's review (new comments + verdict + body) to GitHub. */
+	app.post("/api/gh/submit", async (c) => {
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const body = await c.req.json().catch(() => ({}));
+		const decision = body.decision;
+		if (decision !== "approve" && decision !== "comment" && decision !== "request-changes") return c.json({ error: "decision must be one of: approve, comment, request-changes" }, 400);
+		const generalBody = typeof body.body === "string" ? body.body : "";
+		const dryRun = body.dryRun === true;
+		const result = await submitReview({
+			resolved: {
+				owner: session.owner,
+				repo: session.repo,
+				pullNumber: session.pullNumber,
+				ref: session.ref
+			},
+			decision,
+			body: generalBody,
+			comments: session.comments ?? []
+		});
+		if (result.ok && !dryRun) {
+			const next = {
+				...session,
+				submittedAt: Date.now(),
+				submittedReviewId: result.reviewId,
+				submittedReviewUrl: result.reviewUrl,
+				authSource: result.authSource
+			};
+			await prStore.set(next);
+		}
+		return c.json({
+			ok: result.ok,
+			reviewId: result.reviewId,
+			reviewUrl: result.reviewUrl,
+			failedComments: result.failedComments ?? 0,
+			authSource: result.authSource,
+			error: result.error,
+			dryRun
+		});
+	});
 	app.post("/api/review/send", async (c) => {
 		const body = await c.req.json().catch(() => ({}));
 		const generalComment = typeof body?.generalComment === "string" ? body.generalComment : void 0;
+		const decision = body?.decision === "approved" || body?.decision === "changes-requested" || body?.decision === "rejected" ? body.decision : void 0;
 		const all = await store.getAll();
 		const openCount = all.filter((x) => x.status === "open").length;
 		const payload = reviewSession.send({
 			sentAt: Date.now(),
-			commentXml: formatComments(all, generalComment),
+			commentXml: formatComments(all, generalComment, decision),
 			openCount,
-			comments: all
+			comments: all,
+			decision
 		});
 		return c.json({
 			ok: true,
 			round: payload.round,
 			openCount: payload.openCount,
+			decision: payload.decision,
 			waiters: reviewSession.snapshot().waiters
 		});
 	});
@@ -2182,6 +3111,44 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 	});
 	return app;
 }
+/**
+* Newest mtime (epoch ms) across everything that counts as project activity:
+* comments.json, plans.json, and any attachment (media) file. Plans and media
+* extend a project's life exactly like comments do, so retention is uniform
+* across all three. Returns null when none of them exist yet.
+*/
+async function newestActivityMs(projectDir) {
+	const candidates = [];
+	const safeStat = async (p) => {
+		try {
+			return (await stat(p)).mtimeMs;
+		} catch {
+			return null;
+		}
+	};
+	for (const name of [
+		"comments.json",
+		"plans.json",
+		"pr-session.json"
+	]) {
+		const file = join(projectDir, name);
+		if (!existsSync(file)) continue;
+		const m = await safeStat(file);
+		if (m !== null) candidates.push(m);
+	}
+	const attachmentsDir = join(projectDir, "attachments");
+	if (existsSync(attachmentsDir)) {
+		const dirM = await safeStat(attachmentsDir);
+		if (dirM !== null) candidates.push(dirM);
+		try {
+			for (const file of await readdir(attachmentsDir)) {
+				const m = await safeStat(join(attachmentsDir, file));
+				if (m !== null) candidates.push(m);
+			}
+		} catch {}
+	}
+	return candidates.length ? Math.max(...candidates) : null;
+}
 async function cleanupStaleProjects() {
 	const baseDir = join(homedir(), ".diffing");
 	if (!existsSync(baseDir)) return;
@@ -2192,15 +3159,15 @@ async function cleanupStaleProjects() {
 		for (const entry of entries) if (entry.isDirectory()) {
 			const projectDir = join(baseDir, entry.name);
 			const repoPathFile = join(projectDir, "repo_path.txt");
-			const commentsFile = join(projectDir, "comments.json");
 			let shouldDelete = false;
 			if (existsSync(repoPathFile)) try {
 				const repoPath = (await readFile(repoPathFile, "utf-8")).trim();
 				if (!repoPath || !existsSync(repoPath)) shouldDelete = true;
 			} catch {}
-			if (!shouldDelete && existsSync(commentsFile)) try {
-				if (now - (await stat(commentsFile)).mtimeMs > STALE_TIME) shouldDelete = true;
-			} catch {}
+			if (!shouldDelete) {
+				const newest = await newestActivityMs(projectDir);
+				if (newest !== null && now - newest > STALE_TIME) shouldDelete = true;
+			}
 			if (shouldDelete) await rm(projectDir, {
 				recursive: true,
 				force: true
@@ -2214,20 +3181,484 @@ function startServer(options) {
 	cleanupStaleProjects().catch((err) => {
 		console.error("Failed to clean up stale projects:", err);
 	});
+	let prMode = false;
+	const prReady = (async () => {
+		if (!options.prRef) return;
+		console.error(`Building PR session for ${options.prRef}...`);
+		try {
+			const store = new FilePrSessionStore();
+			const existing = await store.get();
+			if (!existing || existing.ref !== options.prRef) {
+				const session = await buildPrSession(options.prRef);
+				await store.set(session);
+			}
+			prMode = true;
+		} catch (err) {
+			console.error(`[pr-session] failed to build session for ${options.prRef}: ${err?.message ?? err}`);
+		}
+	})();
 	const app = createApp(options.clientDir, options.diffOpts);
 	return new Promise((resolve) => {
-		serve({
-			fetch: app.fetch,
-			port: options.port,
-			hostname: options.host
-		}, (info) => {
-			resolve({ port: info.port });
+		prReady.then(() => {
+			serve({
+				fetch: app.fetch,
+				port: options.port,
+				hostname: options.host
+			}, (info) => {
+				resolve({
+					port: info.port,
+					prMode
+				});
+			});
 		});
 	});
 }
 //#endregion
+//#region src/lib/startup-display.ts
+const R = "\x1B[0m";
+const B = "\x1B[1m";
+const HIDE = "\x1B[?25l";
+const SHOW = "\x1B[?25h";
+const CLR = "\x1B[2K\r";
+const GLITCH_CHARS = "░▒▓█▄▀■□▸▹◆◇";
+const c = (n) => `\x1b[38;5;${n}m`;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const up = (n) => `\x1b[${n}A`;
+const PALETTES = [
+	{
+		base: c(51),
+		text: c(159),
+		faint: c(30),
+		glow: B + c(87),
+		rain: c(37)
+	},
+	{
+		base: c(82),
+		text: c(155),
+		faint: c(22),
+		glow: B + c(118),
+		rain: c(34)
+	},
+	{
+		base: c(207),
+		text: c(219),
+		faint: c(96),
+		glow: B + c(213),
+		rain: c(128)
+	},
+	{
+		base: c(220),
+		text: c(229),
+		faint: c(136),
+		glow: B + c(226),
+		rain: c(178)
+	},
+	{
+		base: c(75),
+		text: c(153),
+		faint: c(25),
+		glow: B + c(81),
+		rain: c(39)
+	},
+	{
+		base: c(214),
+		text: c(223),
+		faint: c(130),
+		glow: B + c(208),
+		rain: c(172)
+	}
+];
+const QUOTES = [
+	{
+		text: "The best code is no code at all.",
+		author: "Jeff Atwood"
+	},
+	{
+		text: "Programs must be written for people to read, and only incidentally for machines to execute.",
+		author: "Abelson & Sussman"
+	},
+	{
+		text: "Make it work, make it right, make it fast.",
+		author: "Kent Beck"
+	},
+	{
+		text: "Simplicity is the soul of efficiency.",
+		author: "Austin Freeman"
+	},
+	{
+		text: "Any fool can write code that a computer can understand. Good programmers write code that humans can understand.",
+		author: "Martin Fowler"
+	},
+	{
+		text: "First, solve the problem. Then, write the code.",
+		author: "John Johnson"
+	},
+	{
+		text: "Code is like humor. When you have to explain it, it's bad.",
+		author: "Cory House"
+	},
+	{
+		text: "Before software can be reusable it first has to be usable.",
+		author: "Ralph Johnson"
+	},
+	{
+		text: "Clean code always looks like it was written by someone who cares.",
+		author: "Robert C. Martin"
+	},
+	{
+		text: "The most dangerous phrase is \"we've always done it this way\".",
+		author: "Grace Hopper"
+	},
+	{
+		text: "Architecture is the decisions you wish you could get right early in a project.",
+		author: "Martin Fowler"
+	},
+	{
+		text: "The best error message is the one that never shows up.",
+		author: "Thomas Fuchs"
+	},
+	{
+		text: "It works on my machine.",
+		author: "Every developer, always"
+	},
+	{
+		text: "git blame yourself.",
+		author: "The terminal"
+	},
+	{
+		text: "There are only two hard things in CS: cache invalidation, naming things, and off-by-one errors.",
+		author: "Unknown"
+	},
+	{
+		text: "Debugging: being the detective in a crime movie where you're also the murderer.",
+		author: "Unknown"
+	},
+	{
+		text: "The code you wrote six months ago was written by an idiot.",
+		author: "Unknown"
+	},
+	{
+		text: "sudo make me a sandwich.",
+		author: "xkcd"
+	},
+	{
+		text: "I don't always test my code, but when I do, I do it in production.",
+		author: "Unknown"
+	},
+	{
+		text: "A QA engineer walks into a bar. Orders 0 beers. Orders 999999 beers. Orders NULL beers. Walks in through the window.",
+		author: "Unknown"
+	},
+	{
+		text: "To understand recursion, you must first understand recursion.",
+		author: "Unknown"
+	},
+	{
+		text: "The code review is the product.",
+		author: "diffing"
+	},
+	{
+		text: "Your abstractions are just someone else's bugs.",
+		author: "Unknown"
+	},
+	{
+		text: "Every rewrite is a confession that you didn't understand the problem the first time.",
+		author: "Unknown"
+	},
+	{
+		text: "The best PR is no PR — ship it in the design.",
+		author: "Unknown"
+	},
+	{
+		text: "You don't own your code. Your code owns you.",
+		author: "Unknown"
+	},
+	{
+		text: "A diff is a conversation. What story does yours tell?",
+		author: "Unknown"
+	},
+	{
+		text: "The senior engineer's superpower: knowing which shortcuts will haunt you.",
+		author: "Unknown"
+	},
+	{
+		text: "Production is the only real test environment.",
+		author: "Site Reliability truth"
+	},
+	{
+		text: "Tech debt is just deferred thinking.",
+		author: "Unknown"
+	},
+	{
+		text: "Comments lie. Code never does.",
+		author: "Ron Jeffries"
+	}
+];
+function wrapText(text, width) {
+	const words = text.split(" ");
+	const lines = [];
+	let cur = "";
+	for (const word of words) {
+		if (!cur) {
+			cur = word;
+			continue;
+		}
+		if (cur.length + 1 + word.length <= width) cur += " " + word;
+		else {
+			lines.push(cur);
+			cur = word;
+		}
+	}
+	if (cur) lines.push(cur);
+	return lines;
+}
+function makeBox(quote, pal) {
+	const termWidth = stdout.columns ?? 80;
+	const maxContent = Math.min(64, termWidth - 8);
+	const fullText = `"${quote.text}"`;
+	const authorStr = `— ${quote.author}`;
+	const textLines = wrapText(fullText, maxContent);
+	return {
+		textLines,
+		authorStr,
+		innerWidth: Math.max(...textLines.map((l) => l.length), authorStr.length, 28) + 4,
+		pal
+	};
+}
+function topBorder(b, borderCol = b.pal.base) {
+	return `${borderCol}╭${"─".repeat(b.innerWidth)}╮${R}`;
+}
+function bottomBorder(b, borderCol = b.pal.base) {
+	return `${borderCol}╰${"─".repeat(b.innerWidth)}╯${R}`;
+}
+function contentRow(b, text, borderCol = b.pal.base, textCol = b.pal.text) {
+	return `${borderCol}│${R}  ${textCol}${text}${R}${" ".repeat(b.innerWidth - 4 - text.length)}  ${borderCol}│${R}`;
+}
+function authorRow(b, borderCol = b.pal.base) {
+	const leading = " ".repeat(b.innerWidth - 4 - b.authorStr.length);
+	return `${borderCol}│${R}  ${b.pal.faint}${leading}${b.authorStr}${R}  ${borderCol}│${R}`;
+}
+function allLines(b, borderCol = b.pal.base) {
+	return [
+		topBorder(b, borderCol),
+		...b.textLines.map((l) => contentRow(b, l, borderCol)),
+		authorRow(b, borderCol),
+		bottomBorder(b, borderCol)
+	];
+}
+function printBox(b) {
+	for (const line of allLines(b)) stdout.write(line + "\n");
+}
+const animTypewriter = async (b) => {
+	stdout.write(topBorder(b) + "\n");
+	for (const line of b.textLines) {
+		stdout.write(`${b.pal.base}│${R}  `);
+		for (let i = 0; i < line.length; i++) {
+			const ch = line[i];
+			stdout.write(`${b.pal.text}${ch}${b.pal.glow}█${R}`);
+			await sleep(25);
+			stdout.write("\b \b");
+		}
+		for (let blink = 0; blink < 2; blink++) {
+			stdout.write(`${b.pal.glow}█${R}`);
+			await sleep(100);
+			stdout.write("\b \b");
+			await sleep(100);
+		}
+		stdout.write(" ".repeat(b.innerWidth - 4 - line.length) + `  ${b.pal.base}│${R}\n`);
+	}
+	stdout.write(authorRow(b) + "\n");
+	stdout.write(bottomBorder(b) + "\n");
+};
+const animWaveReveal = async (b) => {
+	stdout.write(topBorder(b) + "\n");
+	for (const line of b.textLines) {
+		const half = Math.ceil(line.length / 2);
+		stdout.write(contentRow(b, line.slice(0, half).padEnd(line.length), b.pal.base, b.pal.faint) + "\n");
+		await sleep(130);
+		stdout.write(up(1) + CLR + contentRow(b, line) + "\n");
+		await sleep(60);
+	}
+	stdout.write(authorRow(b) + "\n");
+	stdout.write(bottomBorder(b) + "\n");
+};
+const animSlide = async (b) => {
+	const lines = allLines(b);
+	for (let i = 0; i < lines.length; i++) stdout.write("\n");
+	stdout.write(up(lines.length));
+	for (let step = 0; step < 5; step++) {
+		const pad = " ".repeat(Math.floor(12 * (1 - step / 4)));
+		for (const line of lines) stdout.write(CLR + pad + line + "\n");
+		if (step < 4) {
+			stdout.write(up(lines.length));
+			await sleep(80);
+		}
+	}
+};
+const animPulseBorder = async (b) => {
+	const stages = [
+		allLines(b, b.pal.faint),
+		allLines(b, b.pal.base),
+		allLines(b, b.pal.glow),
+		allLines(b, b.pal.base)
+	];
+	for (let s = 0; s < stages.length; s++) {
+		if (s > 0) stdout.write(up(stages[0].length));
+		for (const line of stages[s]) stdout.write((s > 0 ? CLR : "") + line + "\n");
+		if (s < stages.length - 1) await sleep(180);
+	}
+};
+const animGlitch = async (b) => {
+	const noiseRates = [
+		.25,
+		.12,
+		.04,
+		0
+	];
+	const totalLines = b.textLines.length + 3;
+	for (let f = 0; f < noiseRates.length; f++) {
+		if (f > 0) stdout.write(up(totalLines));
+		const rate = noiseRates[f];
+		const clr = f > 0 ? CLR : "";
+		const jitter = rate > 0 ? Math.floor(Math.random() * 3) : 0;
+		const pad = " ".repeat(jitter);
+		stdout.write(clr + pad + topBorder(b) + "\n");
+		for (const line of b.textLines) if (rate === 0) stdout.write(clr + contentRow(b, line) + "\n");
+		else {
+			let inner = "";
+			for (const ch of line) if (Math.random() < rate) {
+				const charColor = Math.random() < .3 ? b.pal.glow : b.pal.base;
+				inner += `${charColor}${GLITCH_CHARS[Math.floor(Math.random() * 12)]}${b.pal.text}`;
+			} else inner += ch;
+			const fill = " ".repeat(b.innerWidth - 4 - line.length);
+			stdout.write(clr + pad + `${b.pal.base}│${R}  ${b.pal.text}${inner}${R}${fill}  ${b.pal.base}│${R}\n`);
+		}
+		stdout.write(clr + pad + authorRow(b) + "\n");
+		stdout.write(clr + pad + bottomBorder(b) + "\n");
+		if (f < noiseRates.length - 1) await sleep(120);
+	}
+};
+const animMatrixRain = async (b) => {
+	const width = b.innerWidth + 2;
+	const RAIN_HEIGHT = 6;
+	const streams = Array.from({ length: RAIN_HEIGHT }, () => Array(width).fill(" "));
+	const chars = "日ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘｱﾎﾏｹﾒｴｶｷﾑﾕﾗｾﾈｽﾀﾇﾍ0123456789";
+	for (let frame = 0; frame < 9; frame++) {
+		for (let y = RAIN_HEIGHT - 1; y > 0; y--) streams[y] = [...streams[y - 1]];
+		streams[0] = Array(width).fill(" ").map(() => {
+			if (Math.random() < .25) return { char: chars[Math.floor(Math.random() * 42)] };
+			return " ";
+		});
+		if (frame > 0) stdout.write(up(RAIN_HEIGHT));
+		for (let y = 0; y < RAIN_HEIGHT; y++) {
+			let line = "";
+			for (let x = 0; x < width; x++) {
+				const cell = streams[y][x];
+				if (cell === " ") line += " ";
+				else {
+					const typedCell = cell;
+					const color = y === 0 ? b.pal.glow : y <= 2 ? b.pal.text : y <= 4 ? b.pal.base : b.pal.faint;
+					line += `${color}${typedCell.char}${R}`;
+				}
+			}
+			stdout.write((frame > 0 ? CLR : "") + line + "\n");
+		}
+		await sleep(90);
+	}
+	stdout.write(up(RAIN_HEIGHT));
+	for (let y = 0; y < RAIN_HEIGHT; y++) stdout.write(CLR + "\n");
+	stdout.write(up(RAIN_HEIGHT));
+	printBox(b);
+};
+const ANIMS = [
+	animTypewriter,
+	animWaveReveal,
+	animSlide,
+	animPulseBorder,
+	animGlitch,
+	animMatrixRain
+];
+function playStartupDisplay() {
+	if (!stdout.isTTY) return Promise.resolve();
+	return (async () => {
+		try {
+			const quote = QUOTES[Math.floor(Math.random() * QUOTES.length)];
+			const pal = PALETTES[Math.floor(Math.random() * PALETTES.length)];
+			const b = makeBox(quote, pal);
+			const anim = ANIMS[Math.floor(Math.random() * ANIMS.length)];
+			stdout.write("\n" + HIDE);
+			await anim(b);
+			stdout.write(SHOW);
+		} catch {
+			try {
+				stdout.write(SHOW);
+			} catch {}
+		}
+	})();
+}
+//#endregion
+//#region src/lib/find-tui-binary.ts
+/**
+* Locate the `diffing-tui` native binary. Looks, in order:
+*   1. Sibling of the calling module (`dist/diffing-tui[.exe]` after build).
+*   2. `bin/diffing-tui[.exe]` next to the package root.
+*   3. `target/release/diffing-tui[.exe]` next to the package root
+*      (cargo release build).
+*   4. `target/debug/diffing-tui[.exe]` next to the package root
+*      (cargo debug build — the common case during development, especially
+*      on Windows where release builds are slow).
+*   5. `$PATH` lookup via `which` / `where`.
+*
+* Returns the absolute path of the first match, or `null` if none are found.
+*
+* `callerUrl` is the `import.meta.url` of the caller — pass `import.meta.url`
+* from `cli.ts`. Exposed as a parameter so unit tests can pin the search
+* root to a known location instead of depending on the test runner's CWD.
+*/
+function findTuiBinary$1(callerUrl) {
+	const ext = process.platform === "win32" ? ".exe" : "";
+	const here = dirname(fileURLToPath(callerUrl));
+	const candidates = [
+		resolve(here, `diffing-tui${ext}`),
+		resolve(here, "..", "bin", `diffing-tui${ext}`),
+		resolve(here, "..", "target", "release", `diffing-tui${ext}`),
+		resolve(here, "..", "..", "target", "release", `diffing-tui${ext}`),
+		resolve(here, "..", "target", "debug", `diffing-tui${ext}`),
+		resolve(here, "..", "..", "target", "debug", `diffing-tui${ext}`)
+	];
+	for (const c of candidates) if (existsSync(c)) return c;
+	try {
+		const out = execFileSync(process.platform === "win32" ? "where" : "which", ["diffing-tui"], {
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		if (out) {
+			const first = out.split(/\r?\n/)[0]?.trim();
+			if (first && isAbsolute(first)) return first;
+		}
+	} catch {}
+	return null;
+}
+//#endregion
 //#region src/cli.ts
 const args = process.argv.slice(2);
+let prRef = null;
+let ghPrConsumed = 0;
+if (args[0]?.startsWith("gh pr ") === true) {
+	const rest = args[0].slice(6).trim();
+	if (rest) {
+		prRef = rest;
+		ghPrConsumed = 1;
+	}
+} else if (args[0] === "gh" && args[1] === "pr" && args[2] !== void 0) {
+	prRef = args[2];
+	ghPrConsumed = 3;
+}
+if (ghPrConsumed > 0) args.splice(0, ghPrConsumed);
 if (new Set([
 	"await-review",
 	"reply",
@@ -2235,17 +3666,31 @@ if (new Set([
 	"comments",
 	"url",
 	"mcp",
-	"plan"
+	"plan",
+	"update",
+	"gh"
 ]).has(args[0])) {
 	if (args[0] === "mcp") {
-		const { startMcpServer } = await import("./mcp-DKlThflu.mjs");
+		const { startMcpServer } = await import("./mcp-BWeWR4yd.mjs");
 		await startMcpServer();
 		await new Promise(() => {});
 	}
-	const { runSubcommand } = await import("./cli-agent-Vbs-ePHv.mjs");
+	const { runSubcommand } = await import("./cli-agent-KxNAFIPf.mjs");
 	process.exit(await runSubcommand(args[0], args.slice(1)));
 }
+let showSubcommand = false;
+if (args[0] === "show") {
+	showSubcommand = true;
+	args.shift();
+}
 const opts = parseDiffOptions(args);
+if (showSubcommand) {
+	if (opts.revisions.length === 0 && !opts.help && !opts.version) {
+		console.error("Usage: diffing show <revspec>... [-- <pathspec>...]");
+		process.exit(5);
+	}
+	intoShowMode(opts);
+}
 if (opts.help) {
 	printHelp();
 	process.exit(0);
@@ -2261,19 +3706,33 @@ if (envErr) {
 	console.error(envErr);
 	process.exit(1);
 }
+if (opts.outputMode === "tui") {
+	const tuiResult = await launchTui(args);
+	process.exit(tuiResult);
+}
 if (opts.outputMode === "terminal") {
 	const exitCode = runTerminalDiff(opts);
 	process.exit(exitCode);
 }
+const __pkgDir = dirname(fileURLToPath(import.meta.url));
+const currentVersion = JSON.parse(readFileSync(resolve(__pkgDir, "..", "package.json"), "utf-8")).version;
+const updateCheckPromise = (async () => {
+	try {
+		const { checkForUpdates } = await import("./update-check-DAPFCqpF.mjs");
+		return await checkForUpdates(currentVersion);
+	} catch {
+		return null;
+	}
+})();
 const port = await getPort(opts.port ? { port: opts.port } : void 0);
 const host = opts.host;
-const clientDir = resolve(dirname(fileURLToPath(import.meta.url)), "client");
-const { existsSync: existsSync$1 } = await import("node:fs");
-const { port: actualPort } = await startServer({
+const clientDir = resolve(__pkgDir, "client");
+const { port: actualPort, prMode } = await startServer({
 	port,
 	host,
-	clientDir: existsSync$1(clientDir) ? clientDir : resolve(process.cwd(), "dist/client"),
-	diffOpts: opts
+	clientDir: existsSync(clientDir) ? clientDir : resolve(process.cwd(), "dist/client"),
+	diffOpts: opts,
+	prRef: prRef ?? void 0
 });
 const localUrl = `http://${host}:${actualPort}`;
 try {
@@ -2283,18 +3742,26 @@ try {
 	} catch {
 		repoRoot = process.cwd();
 	}
-	const __pkgDir = dirname(fileURLToPath(import.meta.url));
-	const version = JSON.parse(readFileSync(resolve(__pkgDir, "..", "package.json"), "utf-8")).version;
 	writeServerLock({
 		port: actualPort,
 		host,
 		pid: process.pid,
 		repoRoot,
 		startedAt: Date.now(),
-		version
+		version: currentVersion,
+		mode: prMode ? "gh-pr" : "web",
+		prRef: prMode ? prRef ?? void 0 : void 0
 	});
 } catch {}
 console.log(`diffing server running at ${localUrl}`);
+await playStartupDisplay();
+try {
+	const updateInfo = await updateCheckPromise;
+	if (updateInfo?.hasUpdate) {
+		const { printUpdateDisclaimer } = await import("./update-check-DAPFCqpF.mjs");
+		printUpdateDisclaimer(currentVersion, updateInfo.latestVersion);
+	}
+} catch {}
 if (!opts.noOpen) {
 	const settings = loadSettings();
 	const openUrl = `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${actualPort}`;
@@ -2311,5 +3778,64 @@ const shutdown = () => {
 };
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
+/**
+* Wrapper around `findTuiBinary` that passes this script's `import.meta.url`
+* so the search paths anchor to the bundled CLI's directory. The real
+* implementation lives in `lib/find-tui-binary.ts` and is unit-tested there.
+*/
+function findTuiBinary() {
+	return findTuiBinary$1(import.meta.url);
+}
+/**
+* Fall back to default `git diff` output when the TUI cannot run.
+* Re-parses `args` so the terminal output exactly matches `diffing` (no flag)
+* in a non-TTY context.
+*/
+function runTerminalFallback(args) {
+	const terminalOpts = parseDiffOptions(args.filter((a) => a !== "--tui"));
+	terminalOpts.outputMode = "terminal";
+	terminalOpts.tui = false;
+	return runTerminalDiff(terminalOpts);
+}
+/**
+* Launch the native-Rust TUI binary as a child process. Returns the process
+* exit code. If the TUI cannot start (no TTY, missing binary), prints a
+* single stderr line and falls back to the default `git diff` output.
+*/
+async function launchTui(args) {
+	if (!process.stdout.isTTY || !process.stdin.isTTY) {
+		console.error("diffing --tui requires a TTY; falling back to git diff");
+		return runTerminalFallback(args);
+	}
+	const bin = findTuiBinary();
+	if (!bin) {
+		console.error("diffing-tui binary not found; build it with `pnpm build:tui`; falling back to git diff");
+		return runTerminalFallback(args);
+	}
+	const forwarded = args.filter((a) => a !== "--tui");
+	let repoRoot;
+	try {
+		repoRoot = getRepoRoot();
+	} catch {
+		repoRoot = process.cwd();
+	}
+	console.log(`diffing TUI starting (binary: ${bin})`);
+	await playStartupDisplay();
+	return new Promise((resolveP) => {
+		const child = spawn(bin, [
+			"--repo",
+			repoRoot,
+			...forwarded
+		], {
+			stdio: "inherit",
+			env: process.env
+		});
+		child.on("exit", (code) => resolveP(code ?? 0));
+		child.on("error", (err) => {
+			console.error(`diffing-tui failed to start: ${err.message}; falling back to git diff`);
+			resolveP(runTerminalFallback(args));
+		});
+	});
+}
 //#endregion
-export {};
+export { findTuiBinary };