diffing 0.4.1 → 0.5.1

package/dist/server-eQ2E4Axo.mjs

@@ -0,0 +1,3367 @@
+import { C as listRepoFiles, E as toSafeRelativePath, S as isGitRepo, T as isSafePath, _ as getRepoRoot, b as getUntrackedFilePathsAsync, c as formatComments, d as getFileContent, f as getGitDiffAsync, g as getRepoName, h as getProjectStorageDir, l as getBranchName, m as getMergeStatus, p as getHunkHistory, u as getCustomGitDiffAsync, v as getShowDiff, w as revertHunk, x as gitAddFile, y as getTabSizeForFiles } from "./server-lock-Ujbcgq28.mjs";
+import { n as formatPlanReview, r as sectionTitleForLine, t as extractPlanLines } from "./plan-format-B6nbAw_c.mjs";
+import { execFile, execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, extname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "node:fs";
+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";
+//#region src/lib/diff-options.ts
+const DEFAULTS$1 = {
+	revisions: [],
+	staged: false,
+	merge: false,
+	pathspecs: [],
+	indentHeuristic: true,
+	noIndentHeuristic: false,
+	ignoreSpaceChange: false,
+	ignoreAllSpace: false,
+	ignoreBlankLines: false,
+	ignoreCrAtEol: false,
+	functionContext: false,
+	patchWithRaw: false,
+	patchWithStat: false,
+	compactSummary: false,
+	cumulative: false,
+	pickaxeAll: false,
+	exitCode: false,
+	quiet: false,
+	noPrefix: false,
+	binary: false,
+	fullIndex: false,
+	text: false,
+	textconv: false,
+	noExtDiff: false,
+	itaVisible: false,
+	noRelative: false,
+	findCopiesHarder: false,
+	check: false,
+	outputMode: "auto",
+	host: "127.0.0.1",
+	noOpen: false,
+	help: false,
+	version: false,
+	includeUnstaged: true,
+	includeUntracked: true,
+	tui: false,
+	gpu: false,
+	showMode: false,
+	showRevspecs: []
+};
+/**
+* All git-diff option definitions for `node:util.parseArgs`.
+* Categorised to match `git diff --help`.
+*/
+const GIT_DIFF_OPTIONS = {
+	staged: { type: "boolean" },
+	cached: { type: "boolean" },
+	merge: { type: "boolean" },
+	"diff-algorithm": { type: "string" },
+	"indent-heuristic": {
+		type: "boolean",
+		default: true
+	},
+	"no-indent-heuristic": { type: "boolean" },
+	anchored: { type: "string" },
+	"ignore-space-change": {
+		type: "boolean",
+		short: "b"
+	},
+	"ignore-all-space": {
+		type: "boolean",
+		short: "w"
+	},
+	"ignore-blank-lines": { type: "boolean" },
+	"ignore-cr-at-eol": { type: "boolean" },
+	"ws-error-highlight": { type: "string" },
+	"unified": {
+		type: "string",
+		short: "U"
+	},
+	"inter-hunk-context": { type: "string" },
+	"function-context": {
+		type: "boolean",
+		short: "W"
+	},
+	"word-diff": { type: "string" },
+	"word-diff-regex": { type: "string" },
+	"color-words": { type: "string" },
+	"color-moved": { type: "string" },
+	"color-moved-ws": { type: "string" },
+	"find-copies": {
+		type: "string",
+		short: "C"
+	},
+	"find-copies-harder": { type: "boolean" },
+	"find-renames": {
+		type: "string",
+		short: "M"
+	},
+	"break-rewrites": {
+		type: "string",
+		short: "B"
+	},
+	patch: {
+		type: "boolean",
+		short: "p"
+	},
+	"no-patch": {
+		type: "boolean",
+		short: "s"
+	},
+	raw: { type: "boolean" },
+	"patch-with-raw": { type: "boolean" },
+	"patch-with-stat": { type: "boolean" },
+	numstat: { type: "boolean" },
+	shortstat: { type: "boolean" },
+	stat: { type: "string" },
+	summary: { type: "boolean" },
+	"name-only": { type: "boolean" },
+	"name-status": { type: "boolean" },
+	check: { type: "boolean" },
+	"compact-summary": { type: "boolean" },
+	dirstat: { type: "string" },
+	"dirstat-by-file": { type: "string" },
+	cumulative: { type: "boolean" },
+	"diff-filter": { type: "string" },
+	S: { type: "string" },
+	G: { type: "string" },
+	"pickaxe-all": { type: "boolean" },
+	output: {
+		type: "string",
+		short: "o"
+	},
+	"exit-code": { type: "boolean" },
+	quiet: { type: "boolean" },
+	"src-prefix": { type: "string" },
+	"dst-prefix": { type: "string" },
+	"no-prefix": { type: "boolean" },
+	"line-prefix": { type: "string" },
+	submodule: { type: "string" },
+	binary: { type: "boolean" },
+	"no-binary": { type: "boolean" },
+	"full-index": { type: "boolean" },
+	text: {
+		type: "boolean",
+		short: "a"
+	},
+	textconv: { type: "boolean" },
+	"no-textconv": { type: "boolean" },
+	"no-ext-diff": { type: "boolean" },
+	"ext-diff": { type: "string" },
+	"ita-visible": { type: "boolean" },
+	"ita-invisible-in-index": { type: "boolean" },
+	relative: { type: "string" },
+	"no-relative": { type: "boolean" },
+	"ignore-submodules": { type: "string" }
+};
+/** Options that are diffing-specific, not git-diff options. */
+const DIFFING_OPTIONS = {
+	port: { type: "string" },
+	host: { type: "string" },
+	"no-open": {
+		type: "boolean",
+		default: false
+	},
+	web: {
+		type: "boolean",
+		default: false
+	},
+	terminal: {
+		type: "boolean",
+		default: false
+	},
+	tui: {
+		type: "boolean",
+		default: false
+	},
+	gpu: {
+		type: "boolean",
+		default: false
+	},
+	"gh-pr": { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h"
+	},
+	version: { type: "boolean" }
+};
+function getVersion() {
+	try {
+		const __dirname = dirname(fileURLToPath(import.meta.url));
+		return JSON.parse(readFileSync(resolve(__dirname, "..", "..", "package.json"), "utf-8")).version;
+	} catch {
+		return "unknown";
+	}
+}
+function printHelp() {
+	const version = getVersion();
+	console.log(`diffing v${version} – Local code review tool for git diffs
+
+Usage: diffing [<git diff options>] [<revision>...] [-- <path>...]
+       diffing --web [<git diff options>] [<revision>...] [-- <path>...]
+       diffing [server options]
+
+Git Diff Options (drop-in replacement for git diff):`);
+	printGitDiffHelp();
+	console.log(`
+Diffing Server Options:
+  --port <port>        Port to run the server on (default: random available port)
+  --host <host>        Host address to bind to (default: 127.0.0.1). Pass
+                       0.0.0.0 to expose the server to the local network.
+  --no-open            Don't open the browser automatically
+
+Output Modes:
+  By default diffing auto-selects the best output mode:
+  - 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, --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 --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(`
+  Revision / Range:
+    --staged, --cached      Show staged changes
+    --merge                 Show merge conflicts
+
+  Diff Algorithm:
+    --diff-algorithm=<A>    Choose diff algorithm (minimal, patience, histogram, myers)
+    --indent-heuristic      Enable indent heuristic (default: on)
+    --no-indent-heuristic   Disable indent heuristic
+    --anchored=<TEXT>       Anchor diff algorithm to <TEXT>
+
+  Whitespace:
+    -b, --ignore-space-change       Ignore changes in amount of whitespace
+    -w, --ignore-all-space          Ignore whitespace when comparing lines
+    --ignore-blank-lines            Ignore blank lines
+    --ignore-cr-at-eol              Ignore carriage-return at EOL
+    --ws-error-highlight=<KIND>     Highlight whitespace errors (none, default, all)
+
+  Context:
+    -U<n>, --unified=<n>           Generate diffs with <n> lines of context
+    --inter-hunk-context=<n>        Show <n> lines between diff hunks
+    -W, --function-context          Show whole function as context
+
+  Word Diff:
+    --word-diff=<MODE>              Word diff (color, plain, porcelain, none)
+    --word-diff-regex=<REGEX>       Regex to determine a word
+    --color-words[=<REGEX>]         Word diff with color
+
+  Moved / Copied Detection:
+    --color-moved=<MODE>            Color moved lines (no, default, plain, blocks, zebra, dimmed-zebra)
+    --color-moved-ws=<MODE>         How whitespace is treated in --color-moved
+    -C[<n>], --find-copies[=<n>]    Detect copies
+    --find-copies-harder            Spend extra cycles to find copies
+    -M[<n>], --find-renames[=<n>]   Detect renames
+    -B[<n>], --break-rewrites[=<n>] Break complete rewrite changes into delete/add pairs
+
+  Output Format:
+    -p, --patch                     Generate patch (default)
+    -s, --no-patch                  Suppress diff output
+    --raw                           Generate raw diff
+    --patch-with-raw                Both patch and raw output
+    --patch-with-stat               Both patch and stat
+    --numstat                       Machine-friendly stat: additions/deletions per file
+    --shortstat                     Summary of additions/deletions
+    --stat[=<width>]                Diffstat with graph
+    --summary                       Extended header summary
+    --name-only                     Show only names of changed files
+    --name-status                   Show only names and status of changed files
+    --check                         Check if diff introduces whitespace errors
+    --compact-summary               Compact summary for submodule changes
+    --dirstat[=<param>]             Directory-level change stats
+    --dirstat-by-file[=<param>]     Per-file directory stats
+    --cumulative                    Cumulative directory stats
+
+  Filtering:
+    --diff-filter=[(A|C|D|M|R|T|U|X|B)...[*]]
+    -S<string>                      Look for differences that change number of occurrences of <string>
+    -G<regex>                       Look for differences whose patch text contains <regex>
+    --pickaxe-all                   Show all changes with -S or -G
+
+  Output Control:
+    -o, --output=<file>             Write diff to <file>
+    --exit-code                     Exit with 1 if differences, 0 if not
+    --quiet                         Disable all output, imply --exit-code
+
+  Prefixes:
+    --src-prefix=<PREFIX>           Source prefix (default: "a/")
+    --dst-prefix=<PREFIX>           Destination prefix (default: "b/")
+    --no-prefix                     Do not show source/destination prefixes
+    --line-prefix=<PREFIX>          Prepend <PREFIX> to every line
+
+  Submodule:
+    --submodule=<FORMAT>            Submodule diff format (diff, log, short)
+
+  Miscellaneous:
+    --binary                        Output binary diff (apply patch to binary files)
+    --no-binary                     Don't output binary diff
+    --full-index                    Show full blob object names
+    -a, --text                      Treat all files as text
+    --textconv                      Allow external text conversion filters
+    --no-textconv                   Disallow external text conversion filters
+    --no-ext-diff                   Disallow external diff drivers
+    --ext-diff=<CMD>                Allow external diff driver
+    --ita-visible                   Include intent-to-add files
+    --ignore-submodules=<WHEN>      Ignore submodule changes
+    --relative[=<path>]             Show changes relative to <path>
+    --no-relative                   Don't show relative paths`);
+}
+/**
+* Parse raw `process.argv` slice into typed DiffOptions.
+*
+* Strategy:
+* 1. Split argv into: [diffing options] [git revisions] [-- pathspecs]
+* 2. Parse known flags via node:util.parseArgs
+* 3. Anything unknown / positional becomes a revision or pathspec
+*/
+function parseDiffOptions(rawArgs) {
+	const { values, positionals } = parseArgs({
+		options: {
+			...GIT_DIFF_OPTIONS,
+			...DIFFING_OPTIONS
+		},
+		allowPositionals: true,
+		strict: false,
+		args: rawArgs
+	});
+	const opts = {
+		...DEFAULTS$1,
+		revisions: [],
+		pathspecs: [],
+		showRevspecs: []
+	};
+	if (values.help) opts.help = true;
+	if (values.version) opts.version = true;
+	if (values.port) opts.port = parseInt(values.port, 10);
+	if (values.host) opts.host = values.host;
+	if (values["no-open"]) opts.noOpen = true;
+	if (values.staged || values.cached) opts.staged = true;
+	if (values.merge) opts.merge = true;
+	const algo = values["diff-algorithm"];
+	if (algo && [
+		"minimal",
+		"patience",
+		"histogram",
+		"myers"
+	].includes(algo)) opts.algorithm = algo;
+	if (values["no-indent-heuristic"]) {
+		opts.noIndentHeuristic = true;
+		opts.indentHeuristic = false;
+	}
+	if (values.anchored) opts.anchored = values.anchored;
+	if (values["ignore-space-change"]) opts.ignoreSpaceChange = true;
+	if (values["ignore-all-space"]) opts.ignoreAllSpace = true;
+	if (values["ignore-blank-lines"]) opts.ignoreBlankLines = true;
+	if (values["ignore-cr-at-eol"]) opts.ignoreCrAtEol = true;
+	const wsh = values["ws-error-highlight"];
+	if (wsh && [
+		"none",
+		"default",
+		"all"
+	].includes(wsh)) opts.wsErrorHighlight = wsh;
+	if (values.unified) opts.unifiedContext = parseInt(values.unified, 10);
+	if (values["inter-hunk-context"]) opts.interHunkContext = parseInt(values["inter-hunk-context"], 10);
+	if (values["function-context"]) opts.functionContext = true;
+	const wd = values["word-diff"];
+	if (wd && [
+		"color",
+		"plain",
+		"porcelain",
+		"none"
+	].includes(wd)) opts.wordDiff = wd;
+	if (values["word-diff-regex"]) opts.wordDiffRegex = values["word-diff-regex"];
+	if (values["color-words"]) {
+		opts.wordDiff = "color";
+		opts.wordDiffRegex = values["color-words"] || void 0;
+	}
+	const cm = values["color-moved"];
+	if (cm && [
+		"default",
+		"plain",
+		"blocks",
+		"zebra",
+		"dimmed-zebra",
+		"no"
+	].includes(cm)) opts.colorMoved = cm;
+	const cmw = values["color-moved-ws"];
+	if (cmw && [
+		"no",
+		"ignore-space-at-eol",
+		"ignore-space-change",
+		"ignore-all-space",
+		"allow-indentation-change"
+	].includes(cmw)) opts.colorMovedWs = cmw;
+	if (values["find-copies"] !== void 0) {
+		const v = values["find-copies"];
+		opts.findCopies = v ? parseInt(v, 10) : 40;
+	}
+	if (values["find-copies-harder"]) opts.findCopiesHarder = true;
+	if (values["find-renames"] !== void 0) {
+		const v = values["find-renames"];
+		opts.findRenames = v ? parseInt(v, 10) : 50;
+	}
+	if (values["break-rewrites"] !== void 0) opts.breakRewrites = values["break-rewrites"];
+	if (values.raw) opts.outputFormat = "raw";
+	if (values.numstat) opts.outputFormat = "numstat";
+	if (values.shortstat) opts.outputFormat = "shortstat";
+	if (values.stat !== void 0) opts.outputFormat = "stat";
+	if (values.summary) opts.outputFormat = "summary";
+	if (values["name-only"]) opts.outputFormat = "name-only";
+	if (values["name-status"]) opts.outputFormat = "name-status";
+	if (values["patch-with-raw"]) opts.patchWithRaw = true;
+	if (values["patch-with-stat"]) opts.patchWithStat = true;
+	if (values["compact-summary"]) opts.compactSummary = true;
+	if (values.dirstat) opts.dirstat = values.dirstat;
+	if (values["dirstat-by-file"]) opts.dirstatByFile = values["dirstat-by-file"];
+	if (values.cumulative) opts.cumulative = true;
+	if (values["no-patch"]) opts.outputFormat = void 0;
+	if (values.check) opts.outputFormat = void 0;
+	if (values["diff-filter"]) opts.diffFilter = values["diff-filter"];
+	if (values.S) opts.pickaxeString = values.S;
+	if (values.G) opts.pickaxeRegex = values.G;
+	if (values["pickaxe-all"]) opts.pickaxeAll = true;
+	if (values.output) opts.outputFile = values.output;
+	if (values["exit-code"]) opts.exitCode = true;
+	if (values.quiet) {
+		opts.quiet = true;
+		opts.exitCode = true;
+	}
+	if (values["src-prefix"]) opts.srcPrefix = values["src-prefix"];
+	if (values["dst-prefix"]) opts.dstPrefix = values["dst-prefix"];
+	if (values["no-prefix"]) opts.noPrefix = true;
+	if (values["line-prefix"]) opts.linePrefix = values["line-prefix"];
+	const sm = values.submodule;
+	if (sm && [
+		"diff",
+		"log",
+		"short"
+	].includes(sm)) opts.submodule = sm;
+	if (values.binary) opts.binary = true;
+	if (values["no-binary"]) opts.binary = false;
+	if (values["full-index"]) opts.fullIndex = true;
+	if (values.text) opts.text = true;
+	if (values.textconv) opts.textconv = true;
+	if (values["no-textconv"]) opts.textconv = false;
+	if (values["no-ext-diff"]) opts.noExtDiff = true;
+	if (values["ext-diff"]) opts.extDiff = values["ext-diff"];
+	if (values["ita-visible"] || values["ita-invisible-in-index"]) opts.itaVisible = true;
+	if (values.relative !== void 0) opts.relative = values.relative || void 0;
+	if (values["no-relative"]) opts.noRelative = true;
+	if (values["ignore-submodules"]) {
+		const ig = values["ignore-submodules"];
+		if ([
+			"none",
+			"untracked",
+			"dirty",
+			"all"
+		].includes(ig)) opts.ignoreSubmodules = ig;
+	}
+	const dashDashIdx = rawArgs.indexOf("--");
+	if (dashDashIdx >= 0) {
+		for (let i = 0; i < dashDashIdx; i++) {
+			const arg = rawArgs[i];
+			if (!arg.startsWith("-")) opts.revisions.push(arg);
+		}
+		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.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";
+	if (opts.outputFormat || opts.patchWithRaw || opts.patchWithStat || opts.exitCode || opts.quiet || opts.outputFile) opts.outputMode = "terminal";
+	return opts;
+}
+/**
+* Build the `git diff` argument array from parsed options.
+* Returns args that can be spread into `git diff <args>`.
+*/
+function buildGitDiffArgs(opts) {
+	const args = [];
+	if (opts.algorithm) args.push(`--diff-algorithm=${opts.algorithm}`);
+	if (opts.noIndentHeuristic) args.push("--no-indent-heuristic");
+	if (opts.anchored) args.push(`--anchored=${opts.anchored}`);
+	if (opts.staged) args.push("--staged");
+	if (opts.merge) args.push("--merge");
+	if (opts.ignoreSpaceChange) args.push("--ignore-space-change");
+	if (opts.ignoreAllSpace) args.push("--ignore-all-space");
+	if (opts.ignoreBlankLines) args.push("--ignore-blank-lines");
+	if (opts.ignoreCrAtEol) args.push("--ignore-cr-at-eol");
+	if (opts.wsErrorHighlight) args.push(`--ws-error-highlight=${opts.wsErrorHighlight}`);
+	if (opts.unifiedContext !== void 0) args.push(`--unified=${opts.unifiedContext}`);
+	if (opts.interHunkContext !== void 0) args.push(`--inter-hunk-context=${opts.interHunkContext}`);
+	if (opts.functionContext) args.push("--function-context");
+	if (opts.wordDiff) if (opts.wordDiff === "color" && opts.wordDiffRegex && !opts.colorWords) {
+		args.push(`--word-diff=color`);
+		args.push(`--word-diff-regex=${opts.wordDiffRegex}`);
+	} else if (opts.wordDiff === "color" && opts.colorWords) args.push(`--color-words=${opts.wordDiffRegex || "."}`);
+	else args.push(`--word-diff=${opts.wordDiff}`);
+	if (opts.wordDiffRegex && opts.wordDiff !== "color") args.push(`--word-diff-regex=${opts.wordDiffRegex}`);
+	if (opts.colorMoved) args.push(`--color-moved=${opts.colorMoved}`);
+	if (opts.colorMovedWs) args.push(`--color-moved-ws=${opts.colorMovedWs}`);
+	if (opts.findCopies !== void 0) args.push(opts.findCopies === 40 ? "-C" : `-C${opts.findCopies}`);
+	if (opts.findCopiesHarder) args.push("--find-copies-harder");
+	if (opts.findRenames !== void 0) args.push(opts.findRenames === 50 ? "-M" : `-M${opts.findRenames}`);
+	if (opts.breakRewrites !== void 0) args.push(`-B${opts.breakRewrites}`);
+	if (opts.outputFormat === "raw") args.push("--raw");
+	if (opts.outputFormat === "numstat") args.push("--numstat");
+	if (opts.outputFormat === "shortstat") args.push("--shortstat");
+	if (opts.outputFormat === "stat") args.push("--stat");
+	if (opts.outputFormat === "summary") args.push("--summary");
+	if (opts.outputFormat === "name-only") args.push("--name-only");
+	if (opts.outputFormat === "name-status") args.push("--name-status");
+	if (opts.patchWithRaw) args.push("--patch-with-raw");
+	if (opts.patchWithStat) args.push("--patch-with-stat");
+	if (opts.compactSummary) args.push("--compact-summary");
+	if (opts.dirstat) args.push(`--dirstat=${opts.dirstat}`);
+	if (opts.dirstatByFile) args.push(`--dirstat-by-file=${opts.dirstatByFile}`);
+	if (opts.cumulative) args.push("--cumulative");
+	if (opts.check) args.push("--check");
+	if (opts.diffFilter) args.push(`--diff-filter=${opts.diffFilter}`);
+	if (opts.pickaxeString) args.push(`-S${opts.pickaxeString}`);
+	if (opts.pickaxeRegex) args.push(`-G${opts.pickaxeRegex}`);
+	if (opts.pickaxeAll) args.push("--pickaxe-all");
+	if (opts.outputFile) args.push(`--output=${opts.outputFile}`);
+	if (opts.exitCode) args.push("--exit-code");
+	if (opts.quiet) args.push("--quiet");
+	if (opts.srcPrefix) args.push(`--src-prefix=${opts.srcPrefix}`);
+	if (opts.dstPrefix) args.push(`--dst-prefix=${opts.dstPrefix}`);
+	if (opts.noPrefix) args.push("--no-prefix");
+	if (opts.linePrefix) args.push(`--line-prefix=${opts.linePrefix}`);
+	if (opts.submodule) args.push(`--submodule=${opts.submodule}`);
+	if (opts.binary) args.push("--binary");
+	if (opts.fullIndex) args.push("--full-index");
+	if (opts.text) args.push("--text");
+	if (opts.textconv) args.push("--textconv");
+	if (opts.noExtDiff) args.push("--no-ext-diff");
+	if (opts.extDiff) args.push(`--ext-diff=${opts.extDiff}`);
+	if (opts.itaVisible) args.push("--ita-visible");
+	if (opts.relative !== void 0) args.push(opts.relative ? `--relative=${opts.relative}` : "--relative");
+	if (opts.noRelative) args.push("--no-relative");
+	if (opts.ignoreSubmodules) args.push(`--ignore-submodules=${opts.ignoreSubmodules}`);
+	for (const rev of opts.revisions) args.push(rev);
+	if (opts.pathspecs.length > 0) {
+		args.push("--");
+		args.push(...opts.pathspecs);
+	}
+	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;
+/**
+* Determine whether to use the "standard" web mode (unstaged+staged+untracked)
+* or a "custom" mode (specific revisions / pathspecs).
+*
+* Custom mode is used when the user provides explicit revisions or pathspecs
+* 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 || opts.showMode;
+}
+function parseFilePaths(patch) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const line of patch.split("\n")) {
+		const match = line.match(/^diff --git a\/.+ b\/(.+)$/);
+		if (match) paths.add(match[1]);
+	}
+	return [...paths];
+}
+function parseBinaryFiles(patch, untrackedFiles) {
+	const binaryFiles = [];
+	const lines = patch.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!line.startsWith("Binary files ") || !line.includes(" differ")) continue;
+		let filePath = "";
+		for (let j = i - 1; j >= 0; j--) {
+			const match = lines[j].match(/^diff --git a\/.+ b\/(.+)$/);
+			if (match) {
+				filePath = match[1];
+				break;
+			}
+		}
+		if (!filePath) continue;
+		let changeType = "changed";
+		for (let j = i - 1; j >= 0; j--) {
+			if (lines[j].startsWith("diff --git")) break;
+			if (lines[j].startsWith("new file mode")) {
+				changeType = "added";
+				break;
+			}
+			if (lines[j].startsWith("deleted file mode")) {
+				changeType = "deleted";
+				break;
+			}
+		}
+		if (changeType === "added" && untrackedFiles?.has(filePath)) changeType = "untracked";
+		binaryFiles.push({
+			path: filePath,
+			type: changeType
+		});
+	}
+	return binaryFiles;
+}
+/**
+* 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 {
+			patch: await getCustomGitDiffAsync(args),
+			args
+		};
+	}
+	return {
+		patch: await getGitDiffAsync({
+			staged: opts.staged,
+			untracked: opts.includeUntracked
+		}),
+		args: []
+	};
+}
+/**
+* Execute a diff and produce the full enriched result used by the web API.
+*/
+async function executeDiffWithMeta(opts) {
+	const { patch, commits, truncated } = await executeDiffAsync(opts);
+	const repoName = getRepoName();
+	const branch = getBranchName();
+	const untrackedFiles = opts.includeUntracked && !opts.showMode ? await getUntrackedFilePathsAsync() : [];
+	const binaryFiles = parseBinaryFiles(patch, new Set(untrackedFiles));
+	const filePaths = parseFilePaths(patch);
+	return {
+		patch,
+		binaryFiles,
+		filePaths,
+		tabSizeMap: getTabSizeForFiles(filePaths),
+		untrackedFiles,
+		repoName,
+		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`. 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 = [];
+	if (enforceDefaults) {
+		if (!args.includes("--no-ext-diff") && !opts.extDiff) finalArgs.push("--no-ext-diff");
+	}
+	finalArgs.push(...args);
+	try {
+		execFileSync("git", ["diff", ...finalArgs], {
+			encoding: "utf-8",
+			maxBuffer: MAX_BUFFER,
+			stdio: "inherit"
+		});
+		return 0;
+	} catch (err) {
+		if (err.status === 1 && opts.exitCode) return 1;
+		return err.status ?? 1;
+	}
+}
+/**
+* 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.
+*/
+function validateEnvironment() {
+	if (!isGitRepo()) return "Error: not inside a git repository";
+	return null;
+}
+//#endregion
+//#region src/lib/symbols.ts
+const SYMBOL_PATTERNS = [
+	{
+		pattern: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w[\w$]*)\s*[<(]/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w[\w$]*)\s*=\s*(?:async\s*)?\(/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w[\w$]*)\s*=\s*(?:async\s+)?function/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?class\s+(\w[\w$]*)/i,
+		kind: "class",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?interface\s+(\w[\w$]*)/i,
+		kind: "interface",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?type\s+(\w[\w$]*)\s*=/i,
+		kind: "type",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?enum\s+(\w[\w$]*)/i,
+		kind: "enum",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w[\w$]*)\s*=/i,
+		kind: "variable",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*def\s+(\w[\w$]*)\s*\(/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?fn\s+(\w[\w$]*)\s*[<(]/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?struct\s+(\w[\w$]*)/i,
+		kind: "struct",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?enum\s+(\w[\w$]*)/i,
+		kind: "enum",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?impl\s+(\w[\w$]*)/i,
+		kind: "impl",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?trait\s+(\w[\w$]*)/i,
+		kind: "trait",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*func\s+(\w[\w$]*)\s*\(/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:func\s+)?\((\w[\w$]*)\s+\*?\w+\)\s+(\w[\w$]*)\s*\(/i,
+		kind: "method",
+		nameGroup: 2
+	}
+];
+/**
+* Returns the symbol defined on this line (name + kind), or null if the line
+* is not a recognizable definition. The first matching pattern wins.
+*/
+function classifySymbolLine(line) {
+	for (const { pattern, kind, nameGroup } of SYMBOL_PATTERNS) {
+		const match = pattern.exec(line);
+		if (match) {
+			const name = match[nameGroup];
+			if (name) return {
+				name,
+				kind
+			};
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/lib/search.ts
+/**
+* Server-side code search powered by `@ff-labs/fff-node` — a native (Rust)
+* fuzzy file finder + live grep. Because it is a native Node addon it cannot
+* run in the browser, so the React client calls the `/api/search` endpoint and
+* this module owns the single long-lived `FileFinder` instance for the repo.
+*
+* Design notes:
+*  - The native binary is loaded lazily via dynamic import inside `init()` so a
+*    missing/incompatible platform binary degrades gracefully (search returns
+*    an error) instead of crashing the whole server at module load.
+*  - One finder per process, keyed implicitly to the repo root. Its frecency /
+*    history databases live under the project's `~/.diffing/<repo>` storage dir
+*    so we never write stray files into the user's repository.
+*  - fff runs its own file-system watcher, so the index stays fresh as the
+*    working tree changes during a review.
+*  - "Symbols" search is plain grep for the identifier, then each hit line is
+*    classified with the shared {@link classifySymbolLine} patterns — fff 0.8.x
+*    does not populate `isDefinition`, so we do the classification ourselves.
+*/
+const DEFAULT_LIMIT = 60;
+const MAX_LIMIT = 200;
+/** Internal page size when no path filter — generous so diff-first client
+*  ranking has enough to work with. */
+const SCAN_PAGE = 200;
+/** Larger page size when filtering to a path set, so the post-filter is
+*  effectively complete for normal-sized diffs/repos. */
+const SCAN_PAGE_FILTERED = 1e3;
+let finder = null;
+let initPromise = null;
+let initError = null;
+let shutdownHooked = false;
+function clampLimit(limit) {
+	if (!limit || limit < 1) return DEFAULT_LIMIT;
+	return Math.min(limit, MAX_LIMIT);
+}
+async function init() {
+	try {
+		const { FileFinder } = await import("@ff-labs/fff-node");
+		const root = getRepoRoot();
+		const dbDir = join(getProjectStorageDir(root), "fff");
+		mkdirSync(dbDir, { recursive: true });
+		const created = FileFinder.create({
+			basePath: root,
+			frecencyDbPath: join(dbDir, "frecency.db"),
+			historyDbPath: join(dbDir, "history.db"),
+			logLevel: "error"
+		});
+		if (!created.ok) {
+			initError = created.error;
+			return null;
+		}
+		const f = created.value;
+		if (!shutdownHooked) {
+			shutdownHooked = true;
+			process.once("exit", () => {
+				try {
+					f.destroy();
+				} catch {}
+			});
+		}
+		await f.waitForScan(8e3);
+		finder = f;
+		return f;
+	} catch (err) {
+		initError = err?.message ?? String(err);
+		return null;
+	}
+}
+async function getFinder() {
+	if (finder) return finder;
+	if (initError) return null;
+	if (!initPromise) initPromise = init();
+	return initPromise;
+}
+function isIndexing(f) {
+	try {
+		return f.isScanning();
+	} catch {
+		return false;
+	}
+}
+async function searchFiles(query, opts = {}) {
+	const f = await getFinder();
+	if (!f) return {
+		scope: "files",
+		items: [],
+		total: 0,
+		indexing: false,
+		error: initError ?? "Search unavailable"
+	};
+	const limit = clampLimit(opts.limit);
+	const pathSet = opts.paths ? new Set(opts.paths) : null;
+	const pageSize = pathSet ? SCAN_PAGE_FILTERED : Math.max(SCAN_PAGE, limit);
+	const res = f.fileSearch(query, { pageSize });
+	if (!res.ok) return {
+		scope: "files",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f),
+		error: res.error
+	};
+	const items = [];
+	const { items: raw, scores } = res.value;
+	for (let i = 0; i < raw.length && items.length < limit; i++) {
+		const it = raw[i];
+		if (pathSet && !pathSet.has(it.relativePath)) continue;
+		const score = scores[i];
+		items.push({
+			path: it.relativePath,
+			fileName: it.fileName,
+			gitStatus: it.gitStatus,
+			matchType: score?.matchType ?? "",
+			exact: !!score?.exactMatch
+		});
+	}
+	return {
+		scope: "files",
+		items,
+		total: res.value.totalMatched,
+		indexing: isIndexing(f)
+	};
+}
+async function searchContent(query, opts = {}) {
+	const f = await getFinder();
+	if (!f) return {
+		scope: "text",
+		items: [],
+		total: 0,
+		indexing: false,
+		error: initError ?? "Search unavailable"
+	};
+	if (!query) return {
+		scope: "text",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f)
+	};
+	const limit = clampLimit(opts.limit);
+	const pathSet = opts.paths ? new Set(opts.paths) : null;
+	const pageSize = pathSet ? SCAN_PAGE_FILTERED : Math.max(SCAN_PAGE, limit);
+	const res = f.grep(query, {
+		mode: opts.regex ? "regex" : "plain",
+		smartCase: true,
+		beforeContext: 0,
+		afterContext: 0,
+		pageSize
+	});
+	if (!res.ok) return {
+		scope: "text",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f),
+		error: res.error
+	};
+	const items = [];
+	for (const m of res.value.items) {
+		if (items.length >= limit) break;
+		if (pathSet && !pathSet.has(m.relativePath)) continue;
+		items.push(toContentHit(m));
+	}
+	return {
+		scope: "text",
+		items,
+		total: res.value.totalMatched,
+		indexing: isIndexing(f),
+		regexError: res.value.regexFallbackError || void 0
+	};
+}
+function toContentHit(m) {
+	return {
+		path: m.relativePath,
+		fileName: m.fileName,
+		line: m.lineNumber,
+		col: m.col,
+		content: m.lineContent,
+		matchRanges: m.matchRanges ?? [],
+		gitStatus: m.gitStatus
+	};
+}
+async function searchSymbols(query, opts = {}) {
+	const f = await getFinder();
+	if (!f) return {
+		scope: "symbols",
+		items: [],
+		total: 0,
+		indexing: false,
+		error: initError ?? "Search unavailable"
+	};
+	if (!query) return {
+		scope: "symbols",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f)
+	};
+	const limit = clampLimit(opts.limit);
+	const pathSet = opts.paths ? new Set(opts.paths) : null;
+	const pageSize = pathSet ? SCAN_PAGE_FILTERED : Math.max(SCAN_PAGE_FILTERED, limit * 8);
+	const res = f.grep(query, {
+		mode: "plain",
+		smartCase: true,
+		beforeContext: 0,
+		afterContext: 0,
+		pageSize
+	});
+	if (!res.ok) return {
+		scope: "symbols",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f),
+		error: res.error
+	};
+	const items = [];
+	const ql = query.toLowerCase();
+	const seen = /* @__PURE__ */ new Set();
+	for (const m of res.value.items) {
+		if (items.length >= limit) break;
+		if (pathSet && !pathSet.has(m.relativePath)) continue;
+		const sym = classifySymbolLine(m.lineContent);
+		if (!sym) continue;
+		if (!sym.name.toLowerCase().includes(ql)) continue;
+		const key = `${m.relativePath}:${m.lineNumber}:${sym.name}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const nameIdx = m.lineContent.indexOf(sym.name);
+		const matchRanges = nameIdx >= 0 ? [[nameIdx, nameIdx + sym.name.length]] : m.matchRanges ?? [];
+		items.push({
+			name: sym.name,
+			kind: sym.kind,
+			path: m.relativePath,
+			fileName: m.fileName,
+			line: m.lineNumber,
+			content: m.lineContent,
+			matchRanges,
+			gitStatus: m.gitStatus
+		});
+	}
+	return {
+		scope: "symbols",
+		items,
+		total: items.length,
+		indexing: isIndexing(f)
+	};
+}
+async function searchAll(query, opts = {}) {
+	const limit = clampLimit(opts.limit);
+	const [filesRes, contentRes, symbolsRes] = await Promise.all([
+		searchFiles(query, {
+			...opts,
+			limit
+		}),
+		searchContent(query, {
+			...opts,
+			limit
+		}),
+		searchSymbols(query, {
+			...opts,
+			limit
+		})
+	]);
+	const items = [];
+	for (const hit of filesRes.items) items.push({
+		kind: "file",
+		hit
+	});
+	for (const hit of symbolsRes.items) items.push({
+		kind: "symbol",
+		hit
+	});
+	for (const hit of contentRes.items) items.push({
+		kind: "text",
+		hit
+	});
+	const total = (filesRes.total || 0) + (contentRes.total || 0) + (symbolsRes.total || 0);
+	const indexing = filesRes.indexing || contentRes.indexing || symbolsRes.indexing;
+	const error = filesRes.error || contentRes.error || symbolsRes.error;
+	const regexError = contentRes.regexError;
+	return {
+		scope: "all",
+		items: items.slice(0, limit),
+		total,
+		indexing,
+		error,
+		regexError
+	};
+}
+async function getSearchStatus() {
+	const f = await getFinder();
+	if (!f) return {
+		available: false,
+		indexing: false,
+		indexedFiles: 0,
+		error: initError ?? "Search unavailable"
+	};
+	let indexedFiles = 0;
+	let indexing = false;
+	try {
+		const prog = f.getScanProgress();
+		if (prog.ok) {
+			indexedFiles = prog.value.scannedFilesCount;
+			indexing = prog.value.isScanning;
+		}
+	} catch {}
+	return {
+		available: true,
+		indexing,
+		indexedFiles
+	};
+}
+/** Record that the user opened `path` from a query, improving fff's frecency
+*  ranking for future searches. Best-effort, never throws. */
+async function trackSelection(query, path) {
+	const f = await getFinder();
+	if (!f) return;
+	try {
+		f.trackQuery(query, path);
+	} catch {}
+}
+//#endregion
+//#region src/lib/settings.ts
+const CONFIG_DIR = join(homedir(), ".config", "diffing");
+const SETTINGS_FILE = join(CONFIG_DIR, "settings.json");
+const DEFAULTS = {
+	staged: true,
+	untracked: true,
+	diffStyle: "split",
+	defaultTabSize: 4,
+	theme: "nord",
+	editorIDE: "default",
+	lineDiffType: "word",
+	lineWrap: false,
+	diffIndicators: "classic",
+	showLineNumbers: true,
+	hunkSeparators: "line-info",
+	lineHoverHighlight: "both",
+	fontSize: 13,
+	expandContextByDefault: false,
+	collapsedContextThreshold: 10,
+	expansionLineCount: 20,
+	haptics: true,
+	sounds: true,
+	uiFont: null,
+	monoFont: null
+};
+function loadSettings() {
+	try {
+		const data = readFileSync(SETTINGS_FILE, "utf-8");
+		return {
+			...DEFAULTS,
+			...JSON.parse(data)
+		};
+	} catch {
+		return { ...DEFAULTS };
+	}
+}
+function saveSettings(settings) {
+	const merged = {
+		...loadSettings(),
+		...settings
+	};
+	mkdirSync(CONFIG_DIR, { recursive: true });
+	writeFileSync(SETTINGS_FILE, JSON.stringify(merged, null, 2));
+	return merged;
+}
+//#endregion
+//#region src/lib/comments.ts
+var FileCommentStore = class {
+	dirPath;
+	filePath;
+	/**
+	* @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() {
+		try {
+			const data = await readFile(this.filePath, "utf-8");
+			return JSON.parse(data);
+		} catch {
+			return [];
+		}
+	}
+	async save(comments) {
+		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(comments, null, 2), "utf-8");
+		} catch (err) {
+			console.error("Failed to save comments to file:", err);
+		}
+	}
+	async add(comment) {
+		const comments = await this.getAll();
+		comments.push(comment);
+		await this.save(comments);
+		return comment;
+	}
+	async update(id, fields) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === id);
+		if (index === -1) return null;
+		const comment = comments[index];
+		if (fields.body !== void 0) comment.body = fields.body;
+		if (fields.status !== void 0) comment.status = fields.status;
+		await this.save(comments);
+		return comment;
+	}
+	async remove(id) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === id);
+		if (index === -1) return false;
+		comments.splice(index, 1);
+		await this.save(comments);
+		return true;
+	}
+	async addReply(commentId, reply) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === commentId);
+		if (index === -1) return null;
+		const comment = comments[index];
+		if (!comment.replies) comment.replies = [];
+		comment.replies.push(reply);
+		await this.save(comments);
+		return comment;
+	}
+	async removeReply(commentId, replyId) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === commentId);
+		if (index === -1) return null;
+		const comment = comments[index];
+		const replyIndex = comment.replies.findIndex((r) => r.id === replyId);
+		if (replyIndex === -1) return null;
+		comment.replies.splice(replyIndex, 1);
+		await this.save(comments);
+		return comment;
+	}
+	async updateReply(commentId, replyId, body) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === commentId);
+		if (index === -1) return null;
+		const comment = comments[index];
+		const reply = comment.replies.find((r) => r.id === replyId);
+		if (!reply) return null;
+		reply.body = body;
+		await this.save(comments);
+		return comment;
+	}
+};
+//#endregion
+//#region src/lib/plans.ts
+function newId() {
+	return crypto.randomUUID();
+}
+/**
+* Backfill / repair a plan loaded from disk so it matches the current schema.
+* Older persisted plans may be missing `versions` and `createdAtPlanVersion`;
+* we synthesize sensible values so callers can always rely on the new fields.
+*/
+function backfillPlan(plan) {
+	const currentVersion = plan.version ?? 1;
+	const have = Array.isArray(plan.versions) ? plan.versions.length : 0;
+	if (!plan.versions || have === 0 || have < currentVersion) {
+		const createdAt = plan.updatedAt ?? plan.createdAt ?? Date.now();
+		const haveEntries = Array.isArray(plan.versions) ? plan.versions : [];
+		const present = new Set(haveEntries.map((v) => v.version));
+		const next = [];
+		for (let i = 1; i <= currentVersion; i++) {
+			const existing = haveEntries.find((v) => v.version === i);
+			if (existing) next.push(existing);
+			else next.push({
+				version: i,
+				body: plan.body,
+				title: plan.title,
+				source: plan.source,
+				model: plan.model,
+				createdAt
+			});
+		}
+		plan.versions = next.filter((v) => v.version >= 1 && v.version <= currentVersion);
+		if (have < currentVersion || !present.has(currentVersion)) markBackfilled(plan);
+	}
+	if (plan.comments) {
+		for (const c of plan.comments) if (typeof c.createdAtPlanVersion !== "number") c.createdAtPlanVersion = plan.version ?? 1;
+	}
+	if (!plan.comments) plan.comments = [];
+}
+function markBackfilled(plan) {
+	plan.__backfilledVersions = true;
+}
+/** Shared mutation helpers so both stores behave identically. */
+function applyUpsert(plans, input, now) {
+	if (input.id) {
+		const existing = plans.find((p) => p.id === input.id);
+		if (existing) {
+			existing.title = input.title;
+			existing.body = input.body;
+			if (input.source !== void 0) existing.source = input.source;
+			if (input.model !== void 0) existing.model = input.model;
+			existing.version += 1;
+			existing.updatedAt = now;
+			if (!existing.versions) existing.versions = [];
+			existing.versions.push({
+				version: existing.version,
+				body: existing.body,
+				title: existing.title,
+				source: existing.source,
+				model: existing.model,
+				createdAt: now
+			});
+			existing.decision = "pending";
+			existing.decisionComment = void 0;
+			existing.decidedAt = void 0;
+			return existing;
+		}
+	}
+	const plan = {
+		id: input.id || newId(),
+		title: input.title,
+		body: input.body,
+		source: input.source,
+		model: input.model,
+		createdAt: now,
+		updatedAt: now,
+		version: 1,
+		decision: "pending",
+		comments: [],
+		versions: [{
+			version: 1,
+			body: input.body,
+			title: input.title,
+			source: input.source,
+			model: input.model,
+			createdAt: now
+		}]
+	};
+	plans.push(plan);
+	return plan;
+}
+/**
+* Keep the most-recent `PlanVersion` snapshot in sync with the current `Plan`
+* fields after a non-resubmit edit (PUT). Doesn't add a new entry — that only
+* happens via `upsert` (the resubmit flow).
+*/
+function syncCurrentVersion(plan) {
+	if (!plan.versions || plan.versions.length === 0) plan.versions = [];
+	if (plan.versions.length === 0) {
+		plan.versions.push({
+			version: plan.version,
+			body: plan.body,
+			title: plan.title,
+			source: plan.source,
+			model: plan.model,
+			createdAt: plan.updatedAt
+		});
+		return;
+	}
+	const last = plan.versions[plan.versions.length - 1];
+	last.body = plan.body;
+	last.title = plan.title;
+	last.source = plan.source;
+	last.model = plan.model;
+}
+var FilePlanStore = class {
+	dirPath;
+	filePath;
+	/**
+	* @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() {
+		try {
+			const data = await readFile(this.filePath, "utf-8");
+			const plans = JSON.parse(data);
+			let anyBackfilled = false;
+			for (const p of plans) {
+				const before = Array.isArray(p.versions) ? p.versions.length : 0;
+				const beforeValid = Array.isArray(p.versions) && p.versions.length > 0;
+				backfillPlan(p);
+				const after = Array.isArray(p.versions) ? p.versions.length : 0;
+				if ((!beforeValid || before < (p.version ?? 1)) && after > before) anyBackfilled = true;
+			}
+			if (anyBackfilled) try {
+				await this.save(plans);
+			} catch {}
+			return plans;
+		} catch {
+			return [];
+		}
+	}
+	async get(id) {
+		return (await this.getAll()).find((p) => p.id === id) ?? null;
+	}
+	async getVersion(id, version) {
+		const plan = await this.get(id);
+		if (!plan) return null;
+		return plan.versions.find((v) => v.version === version) ?? null;
+	}
+	async save(plans) {
+		try {
+			await mkdir(this.dirPath, { recursive: true });
+			try {
+				const repoRoot = getRepoRoot();
+				await writeFile(join(this.dirPath, "repo_path.txt"), repoRoot, "utf-8");
+			} catch {}
+			const clean = plans.map((p) => {
+				const copy = { ...p };
+				delete copy.__backfilledVersions;
+				return copy;
+			});
+			await writeFile(this.filePath, JSON.stringify(clean, null, 2), "utf-8");
+		} catch (err) {
+			console.error("Failed to save plans to file:", err);
+		}
+	}
+	async upsert(input) {
+		const plans = await this.getAll();
+		const plan = applyUpsert(plans, input, Date.now());
+		backfillPlan(plan);
+		await this.save(plans);
+		return plan;
+	}
+	async update(id, fields) {
+		const plans = await this.getAll();
+		const plan = plans.find((p) => p.id === id);
+		if (!plan) return null;
+		if (fields.title !== void 0) plan.title = fields.title;
+		if (fields.body !== void 0) plan.body = fields.body;
+		if (fields.source !== void 0) plan.source = fields.source;
+		if (fields.model !== void 0) plan.model = fields.model;
+		plan.updatedAt = Date.now();
+		syncCurrentVersion(plan);
+		backfillPlan(plan);
+		await this.save(plans);
+		return plan;
+	}
+	async remove(id) {
+		const plans = await this.getAll();
+		const idx = plans.findIndex((p) => p.id === id);
+		if (idx === -1) return false;
+		plans.splice(idx, 1);
+		await this.save(plans);
+		return true;
+	}
+	async setDecision(id, decision, decisionComment) {
+		const plans = await this.getAll();
+		const plan = plans.find((p) => p.id === id);
+		if (!plan) return null;
+		plan.decision = decision;
+		plan.decisionComment = decisionComment?.trim() || void 0;
+		plan.decidedAt = Date.now();
+		plan.updatedAt = plan.decidedAt;
+		await this.save(plans);
+		return plan;
+	}
+	async mutate(planId, fn) {
+		const plans = await this.getAll();
+		const plan = plans.find((p) => p.id === planId);
+		if (!plan) return null;
+		if (!plan.comments) plan.comments = [];
+		if (!fn(plan)) return null;
+		backfillPlan(plan);
+		await this.save(plans);
+		return plan;
+	}
+	async addComment(planId, comment) {
+		return this.mutate(planId, (plan) => {
+			if (typeof comment.createdAtPlanVersion !== "number") comment.createdAtPlanVersion = plan.version ?? 1;
+			plan.comments.push(comment);
+			return true;
+		});
+	}
+	async updateComment(planId, commentId, fields) {
+		return this.mutate(planId, (plan) => {
+			const c = plan.comments.find((x) => x.id === commentId);
+			if (!c) return false;
+			if (fields.body !== void 0) c.body = fields.body;
+			if (fields.status !== void 0) c.status = fields.status;
+			return true;
+		});
+	}
+	async removeComment(planId, commentId) {
+		return this.mutate(planId, (plan) => {
+			const idx = plan.comments.findIndex((x) => x.id === commentId);
+			if (idx === -1) return false;
+			plan.comments.splice(idx, 1);
+			return true;
+		});
+	}
+	async addReply(planId, commentId, reply) {
+		return this.mutate(planId, (plan) => {
+			const c = plan.comments.find((x) => x.id === commentId);
+			if (!c) return false;
+			if (typeof c.createdAtPlanVersion === "number" && typeof reply.createdAtPlanVersion !== "number") reply.createdAtPlanVersion = c.createdAtPlanVersion;
+			if (!c.replies) c.replies = [];
+			c.replies.push(reply);
+			return true;
+		});
+	}
+	async removeReply(planId, commentId, replyId) {
+		return this.mutate(planId, (plan) => {
+			const c = plan.comments.find((x) => x.id === commentId);
+			if (!c) return false;
+			const idx = c.replies.findIndex((r) => r.id === replyId);
+			if (idx === -1) return false;
+			c.replies.splice(idx, 1);
+			return true;
+		});
+	}
+	async updateReply(planId, commentId, replyId, body) {
+		return this.mutate(planId, (plan) => {
+			const c = plan.comments.find((x) => x.id === commentId);
+			if (!c) return false;
+			const reply = c.replies.find((r) => r.id === replyId);
+			if (!reply) return false;
+			reply.body = body;
+			return true;
+		});
+	}
+};
+//#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;
+	lastSentAt = null;
+	lastPayload = null;
+	waiters = /* @__PURE__ */ new Set();
+	onStatusChange;
+	constructor(onStatusChange) {
+		this.onStatusChange = onStatusChange;
+	}
+	/**
+	* Block until the next `send()` or until `timeoutMs` elapses.
+	*
+	* If `sinceRound` is provided and is behind the current round, a send already
+	* happened since the client last checked → resolve immediately with the
+	* cached payload (the race guard). Otherwise register a waiter.
+	*/
+	await(opts) {
+		const { sinceRound, timeoutMs, signal } = opts;
+		if (sinceRound !== void 0 && sinceRound < this.round && this.lastPayload) return Promise.resolve({
+			status: "released",
+			payload: this.lastPayload
+		});
+		if (signal?.aborted) return Promise.resolve({
+			status: "keep-waiting",
+			round: this.round
+		});
+		return new Promise((resolve) => {
+			const waiter = {
+				resolve,
+				timer: setTimeout(() => {
+					this.removeWaiter(waiter);
+					resolve({
+						status: "keep-waiting",
+						round: this.round
+					});
+				}, timeoutMs),
+				cleanup: () => {}
+			};
+			if (signal) {
+				const onAbort = () => {
+					this.removeWaiter(waiter);
+					resolve({
+						status: "keep-waiting",
+						round: this.round
+					});
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				waiter.cleanup = () => signal.removeEventListener("abort", onAbort);
+			}
+			this.waiters.add(waiter);
+			this.emitStatus();
+		});
+	}
+	/** Capture a review batch and release every blocked waiter. */
+	send(input) {
+		this.round += 1;
+		this.lastSentAt = input.sentAt;
+		const payload = {
+			round: this.round,
+			sentAt: input.sentAt,
+			commentXml: input.commentXml,
+			openCount: input.openCount,
+			comments: input.comments,
+			decision: input.decision,
+			mode: input.mode ?? "standard"
+		};
+		this.lastPayload = payload;
+		const waiters = [...this.waiters];
+		this.waiters.clear();
+		for (const waiter of waiters) {
+			clearTimeout(waiter.timer);
+			waiter.cleanup();
+			waiter.resolve({
+				status: "released",
+				payload
+			});
+		}
+		this.emitStatus();
+		return payload;
+	}
+	snapshot() {
+		return {
+			round: this.round,
+			waiters: this.waiters.size,
+			lastSentAt: this.lastSentAt
+		};
+	}
+	removeWaiter(waiter) {
+		if (!this.waiters.delete(waiter)) return;
+		clearTimeout(waiter.timer);
+		waiter.cleanup();
+		this.emitStatus();
+	}
+	emitStatus() {
+		this.onStatusChange?.(this.snapshot());
+	}
+};
+//#endregion
+//#region src/lib/plan-review-session.ts
+var PlanReviewSession = class {
+	round = 0;
+	lastDecidedAt = null;
+	lastPayload = null;
+	waiters = /* @__PURE__ */ new Set();
+	onStatusChange;
+	constructor(onStatusChange) {
+		this.onStatusChange = onStatusChange;
+	}
+	/** Block until the next `decide()` or until `timeoutMs` elapses. */
+	await(opts) {
+		const { sinceRound, timeoutMs, signal } = opts;
+		if (sinceRound !== void 0 && sinceRound < this.round && this.lastPayload) return Promise.resolve({
+			status: "released",
+			payload: this.lastPayload
+		});
+		if (signal?.aborted) return Promise.resolve({
+			status: "keep-waiting",
+			round: this.round
+		});
+		return new Promise((resolve) => {
+			const waiter = {
+				resolve,
+				timer: setTimeout(() => {
+					this.removeWaiter(waiter);
+					resolve({
+						status: "keep-waiting",
+						round: this.round
+					});
+				}, timeoutMs),
+				cleanup: () => {}
+			};
+			if (signal) {
+				const onAbort = () => {
+					this.removeWaiter(waiter);
+					resolve({
+						status: "keep-waiting",
+						round: this.round
+					});
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				waiter.cleanup = () => signal.removeEventListener("abort", onAbort);
+			}
+			this.waiters.add(waiter);
+			this.emitStatus();
+		});
+	}
+	/** Capture a decision and release every blocked waiter. */
+	decide(input) {
+		this.round += 1;
+		this.lastDecidedAt = input.sentAt;
+		const payload = {
+			round: this.round,
+			sentAt: input.sentAt,
+			planId: input.planId,
+			decision: input.decision,
+			decisionComment: input.decisionComment,
+			reviewXml: input.reviewXml,
+			openCommentCount: input.openCommentCount,
+			plan: input.plan,
+			mode: input.mode ?? "standard"
+		};
+		this.lastPayload = payload;
+		const waiters = [...this.waiters];
+		this.waiters.clear();
+		for (const waiter of waiters) {
+			clearTimeout(waiter.timer);
+			waiter.cleanup();
+			waiter.resolve({
+				status: "released",
+				payload
+			});
+		}
+		this.emitStatus();
+		return payload;
+	}
+	snapshot() {
+		return {
+			round: this.round,
+			waiters: this.waiters.size,
+			lastDecidedAt: this.lastDecidedAt
+		};
+	}
+	removeWaiter(waiter) {
+		if (!this.waiters.delete(waiter)) return;
+		clearTimeout(waiter.timer);
+		waiter.cleanup();
+		this.emitStatus();
+	}
+	emitStatus() {
+		this.onStatusChange?.(this.snapshot());
+	}
+};
+//#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",
+	".js": "application/javascript",
+	".css": "text/css",
+	".json": "application/json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".ico": "image/x-icon",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".bmp": "image/bmp",
+	".avif": "image/avif"
+};
+function isCustomMode(opts) {
+	return opts.revisions.length > 0 || opts.pathspecs.length > 0 || opts.showMode;
+}
+function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore, prSessionStore, prMode = false) {
+	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) => {
+		for (const send of activeClients) try {
+			send(event, data);
+		} catch {}
+	};
+	const reviewSession = new ReviewSession((snapshot) => broadcast("agent-status", JSON.stringify(snapshot)));
+	const planReviewSession = new PlanReviewSession((snapshot) => broadcast("plan-review-status", JSON.stringify(snapshot)));
+	let repoRoot;
+	try {
+		repoRoot = getRepoRoot();
+	} catch {
+		repoRoot = process.cwd();
+	}
+	if (!commentStore && !planStore) try {
+		const storageDir = getProjectStorageDir();
+		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")) {
+				if (commentsDebounce) clearTimeout(commentsDebounce);
+				commentsDebounce = setTimeout(() => broadcast("comments", Date.now().toString()), 120);
+			} 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) {
+		console.warn("Failed to initialize storage watcher:", err);
+	}
+	let debounceTimeout = null;
+	try {
+		watch(repoRoot, { recursive: true }, (eventType, filename) => {
+			if (!filename) return;
+			const parts = filename.split(/[/\\]/);
+			const isGit = parts.includes(".git");
+			const isNodeModules = parts.includes("node_modules");
+			const isDist = parts.includes("dist");
+			const isChangeset = parts.includes(".changeset");
+			let shouldTrigger = false;
+			if (isGit) {
+				const isIndex = filename.endsWith("index");
+				const isHead = filename.endsWith("HEAD");
+				const isRefs = filename.includes("refs/") || filename.includes("refs\\");
+				if (isIndex || isHead || isRefs) shouldTrigger = true;
+			} else if (!isNodeModules && !isDist && !isChangeset) shouldTrigger = true;
+			if (shouldTrigger) {
+				if (debounceTimeout) clearTimeout(debounceTimeout);
+				debounceTimeout = setTimeout(() => broadcast("change", Date.now().toString()), 200);
+			}
+		}).unref();
+	} catch (err) {
+		console.warn("Failed to initialize repository watcher:", err);
+	}
+	app.get("/api/live", async (c) => {
+		return streamSSE(c, async (stream) => {
+			const sendUpdate = (event, data) => {
+				stream.writeSSE({
+					event,
+					data
+				});
+			};
+			activeClients.add(sendUpdate);
+			await stream.writeSSE({
+				event: "heartbeat",
+				data: Date.now().toString()
+			});
+			const heartbeatInterval = setInterval(() => {
+				stream.writeSSE({
+					event: "heartbeat",
+					data: Date.now().toString()
+				}).catch(() => {});
+			}, 15e3);
+			await new Promise((resolve) => {
+				stream.onAbort(() => {
+					clearInterval(heartbeatInterval);
+					activeClients.delete(sendUpdate);
+					resolve();
+				});
+			});
+		});
+	});
+	app.get("/api/diff", async (c) => {
+		const stagedQuery = c.req.query("staged");
+		const untrackedQuery = c.req.query("untracked");
+		const staged = stagedQuery === void 0 ? diffOpts.staged : stagedQuery === "true";
+		const untracked = untrackedQuery === void 0 ? diffOpts.includeUntracked : untrackedQuery === "true";
+		if (prMode) {
+			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,
+			branch: result.branch,
+			customMode,
+			binaryFiles: result.binaryFiles,
+			tabSizeMap: result.tabSizeMap,
+			untrackedFiles: result.untrackedFiles,
+			showMode: optsForDiff.showMode || void 0,
+			commits: result.commits,
+			truncated: result.truncated
+		});
+	});
+	app.get("/api/file-content", (c) => {
+		const path = c.req.query("path");
+		const version = c.req.query("version");
+		if (!path || !version) return c.json({ error: "Missing path or version" }, 400);
+		const content = getFileContent(path, version);
+		if (!content) return c.json({ error: "File not found" }, 404);
+		const contentType = MIME_TYPES[extname(path)] || "application/octet-stream";
+		return new Response(new Uint8Array(content), { headers: { "Content-Type": contentType } });
+	});
+	app.get("/api/file-text", (c) => {
+		const path = c.req.query("path");
+		const version = c.req.query("version");
+		if (!path || !version) return c.json({ error: "Missing path or version" }, 400);
+		const buffer = getFileContent(path, version);
+		if (!buffer) return c.json({
+			content: "",
+			missing: true
+		});
+		const sample = buffer.subarray(0, Math.min(buffer.length, 8192));
+		for (let i = 0; i < sample.length; i++) if (sample[i] === 0) return c.json({ error: "Binary file" }, 415);
+		return c.json({
+			content: buffer.toString("utf-8"),
+			missing: false
+		});
+	});
+	app.post("/api/open-file", async (c) => {
+		const { filePath, editor } = await c.req.json();
+		if (!filePath) return c.json({ error: "filePath is required" }, 400);
+		try {
+			const root = getRepoRoot();
+			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);
+		}
+	});
+	app.get("/api/repo-files", (c) => {
+		try {
+			return c.json({ files: listRepoFiles() });
+		} catch (err) {
+			return c.json({ error: err.message }, 500);
+		}
+	});
+	app.post("/api/search", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const scope = body.scope ?? "files";
+		const query = typeof body.query === "string" ? body.query : "";
+		const limit = typeof body.limit === "number" ? body.limit : void 0;
+		const paths = Array.isArray(body.changedPaths) ? body.changedPaths : void 0;
+		try {
+			if (scope === "all") return c.json(await searchAll(query, {
+				limit,
+				regex: !!body.regex,
+				paths
+			}));
+			if (scope === "text") return c.json(await searchContent(query, {
+				limit,
+				regex: !!body.regex,
+				paths
+			}));
+			if (scope === "symbols") return c.json(await searchSymbols(query, {
+				limit,
+				paths
+			}));
+			return c.json(await searchFiles(query, {
+				limit,
+				paths
+			}));
+		} catch (err) {
+			return c.json({
+				scope,
+				items: [],
+				total: 0,
+				indexing: false,
+				error: err?.message ?? "Search failed"
+			}, 500);
+		}
+	});
+	app.get("/api/search/status", async (c) => {
+		return c.json(await getSearchStatus());
+	});
+	app.post("/api/search/track", async (c) => {
+		const { query, path } = await c.req.json().catch(() => ({}));
+		if (path) await trackSelection(query ?? "", path);
+		return c.json({ ok: true });
+	});
+	app.get("/api/merge-status", (c) => {
+		try {
+			const status = getMergeStatus();
+			return c.json(status);
+		} catch (err) {
+			return c.json({ error: err.message }, 500);
+		}
+	});
+	app.post("/api/revert-hunk", async (c) => {
+		const { filePath, hunkIndex } = await c.req.json();
+		if (!filePath || typeof hunkIndex !== "number") return c.json({ error: "Missing filePath or hunkIndex" }, 400);
+		try {
+			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") : "";
+			return c.json({ error: stderr || err?.message || "Failed to revert hunk" }, 500);
+		}
+	});
+	app.get("/api/hunk-history", async (c) => {
+		const filePath = c.req.query("filePath");
+		const deletionStart = Number(c.req.query("deletionStart"));
+		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 {
+			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);
+		}
+	});
+	app.post("/api/save-file", async (c) => {
+		const { filePath, content, gitAdd } = await c.req.json();
+		if (!filePath || typeof content !== "string") return c.json({ error: "Missing filePath or content" }, 400);
+		try {
+			const root = getRepoRoot();
+			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(relPath);
+			} catch (err) {
+				return c.json({
+					ok: true,
+					gitAddError: err.message
+				});
+			}
+			return c.json({ ok: true });
+		} catch (err) {
+			return c.json({ error: `Failed to save file: ${err.message}` }, 500);
+		}
+	});
+	app.get("/api/settings", (c) => {
+		return c.json(loadSettings());
+	});
+	app.put("/api/settings", async (c) => {
+		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]);
+	});
+	app.put("/api/viewed", async (c) => {
+		const { filePath, viewed } = await c.req.json();
+		if (viewed) viewedFiles.add(filePath);
+		else viewedFiles.delete(filePath);
+		return c.json({ ok: true });
+	});
+	app.get("/api/comments", async (c) => {
+		const comments = await store.getAll();
+		return c.json(comments);
+	});
+	app.post("/api/comments", async (c) => {
+		const body = await c.req.json();
+		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 created = await store.add(comment);
+		return c.json(created, 201);
+	});
+	app.put("/api/comments/:id", async (c) => {
+		const id = c.req.param("id");
+		const { body, status } = await c.req.json();
+		const updated = await store.update(id, {
+			body,
+			status
+		});
+		if (!updated) return c.json({ error: "Comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.post("/api/comments/:id/replies", async (c) => {
+		const commentId = c.req.param("id");
+		const { body, role, model } = await c.req.json();
+		const reply = {
+			id: crypto.randomUUID(),
+			body,
+			createdAt: Date.now(),
+			role: role || (model ? "agent" : "user"),
+			model: model || void 0
+		};
+		const updated = await store.addReply(commentId, reply);
+		if (!updated) return c.json({ error: "Comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/comments/:id/replies/:replyId", async (c) => {
+		const commentId = c.req.param("id");
+		const replyId = c.req.param("replyId");
+		const updated = await store.removeReply(commentId, replyId);
+		if (!updated) return c.json({ error: "Comment or reply not found" }, 404);
+		return c.json(updated);
+	});
+	app.put("/api/comments/:id/replies/:replyId", async (c) => {
+		const commentId = c.req.param("id");
+		const replyId = c.req.param("replyId");
+		const { body } = await c.req.json();
+		if (!body) return c.json({ error: "Body is required" }, 400);
+		const updated = await store.updateReply(commentId, replyId, body);
+		if (!updated) return c.json({ error: "Comment or reply not found" }, 404);
+		return c.json(updated);
+	});
+	app.post("/api/comments/:id/apply-suggestion", async (c) => {
+		const id = c.req.param("id");
+		const comment = (await store.getAll()).find((c) => c.id === id);
+		if (!comment) return c.json({ error: "Comment not found" }, 404);
+		if (comment.side !== "additions") return c.json({ error: "Suggestions can only be applied to added or modified lines" }, 400);
+		const match = comment.body.match(/```suggestion\n([\s\S]*?)```/);
+		if (!match) return c.json({ error: "No suggestion block found in comment body" }, 400);
+		const suggestion = match[1];
+		try {
+			const root = getRepoRoot();
+			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);
+			lines[lineIdx] = suggestion.trimEnd();
+			await writeFile(absolutePath, lines.join("\n"), "utf-8");
+			await store.update(id, { status: "resolved" });
+			return c.json({ ok: true });
+		} catch (err) {
+			return c.json({ error: `Failed to apply suggestion: ${err.message}` }, 500);
+		}
+	});
+	app.delete("/api/comments/:id", async (c) => {
+		const id = c.req.param("id");
+		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) => {
+		if (!prMode) return notInPrMode(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) => {
+		if (!prMode) return notInPrMode(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) => {
+		if (!prMode) return notInPrMode(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) => {
+		if (!prMode) return notInPrMode(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) => {
+		if (!prMode) return notInPrMode(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) => {
+		if (!prMode) return notInPrMode(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) => {
+		if (!prMode) return notInPrMode(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) => {
+		if (!prMode) return notInPrMode(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) => {
+		if (!prMode) return notInPrMode(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 === "comment-only" ? body.decision : void 0;
+		const mode = body?.mode === "comment-only" || body?.mode === "standard" ? body.mode : "standard";
+		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, decision, mode),
+			openCount,
+			comments: all,
+			decision,
+			mode
+		});
+		return c.json({
+			ok: true,
+			round: payload.round,
+			openCount: payload.openCount,
+			decision: payload.decision,
+			mode: payload.mode,
+			waiters: reviewSession.snapshot().waiters
+		});
+	});
+	app.get("/api/review/await", async (c) => {
+		const sinceRaw = c.req.query("sinceRound");
+		const sinceRound = sinceRaw !== void 0 && sinceRaw !== "" ? Number(sinceRaw) : void 0;
+		const requested = Number(c.req.query("timeoutMs")) || 25e3;
+		const timeoutMs = Math.min(Math.max(requested, 1e3), 5e4);
+		const result = await reviewSession.await({
+			sinceRound: Number.isNaN(sinceRound) ? void 0 : sinceRound,
+			timeoutMs,
+			signal: c.req.raw.signal
+		});
+		return c.json(result);
+	});
+	app.get("/api/review/status", (c) => {
+		return c.json(reviewSession.snapshot());
+	});
+	app.get("/api/plans", async (c) => {
+		return c.json(await plans.getAll());
+	});
+	app.get("/api/plans/:id", async (c) => {
+		const plan = await plans.get(c.req.param("id"));
+		if (!plan) return c.json({ error: "Plan not found" }, 404);
+		return c.json(plan);
+	});
+	app.get("/api/plans/:id/versions", async (c) => {
+		const plan = await plans.get(c.req.param("id"));
+		if (!plan) return c.json({ error: "Plan not found" }, 404);
+		return c.json(plan.versions ?? []);
+	});
+	app.get("/api/plans/:id/versions/:n", async (c) => {
+		const id = c.req.param("id");
+		const n = Number(c.req.param("n"));
+		if (!Number.isFinite(n) || n < 1) return c.json({ error: "version must be a positive integer" }, 400);
+		const plan = await plans.get(id);
+		if (!plan) return c.json({ error: "Plan not found" }, 404);
+		const version = (plan.versions ?? []).find((v) => v.version === n);
+		if (!version) return c.json({ error: `Version ${n} not found` }, 404);
+		return c.json({
+			version,
+			plan: {
+				id: plan.id,
+				title: plan.title,
+				decision: plan.decision,
+				currentVersion: plan.version
+			}
+		});
+	});
+	app.post("/api/plans", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		if (typeof body.body !== "string" || !body.body.trim()) return c.json({ error: "A plan body (markdown) is required" }, 400);
+		const title = typeof body.title === "string" && body.title.trim() ? body.title.trim() : "Untitled plan";
+		const plan = await plans.upsert({
+			id: typeof body.id === "string" && body.id ? body.id : void 0,
+			title,
+			body: body.body,
+			source: typeof body.source === "string" ? body.source : void 0,
+			model: typeof body.model === "string" ? body.model : void 0
+		});
+		return c.json(plan, 201);
+	});
+	app.put("/api/plans/:id", async (c) => {
+		const id = c.req.param("id");
+		const { title, body, source, model } = await c.req.json().catch(() => ({}));
+		const updated = await plans.update(id, {
+			title: typeof title === "string" ? title : void 0,
+			body: typeof body === "string" ? body : void 0,
+			source: typeof source === "string" ? source : void 0,
+			model: typeof model === "string" ? model : void 0
+		});
+		if (!updated) return c.json({ error: "Plan not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/plans/:id", async (c) => {
+		if (!await plans.remove(c.req.param("id"))) return c.json({ error: "Plan not found" }, 404);
+		return c.json({ ok: true });
+	});
+	app.post("/api/plans/:id/comments", async (c) => {
+		const planId = c.req.param("id");
+		const plan = await plans.get(planId);
+		if (!plan) return c.json({ error: "Plan not found" }, 404);
+		const body = await c.req.json();
+		const lineNumber = Number.isFinite(body.lineNumber) ? Number(body.lineNumber) : 0;
+		const startLineNumber = Number.isFinite(body.startLineNumber) ? Number(body.startLineNumber) : void 0;
+		const anchorStart = startLineNumber ?? lineNumber;
+		const lineContent = typeof body.lineContent === "string" && body.lineContent ? body.lineContent : lineNumber > 0 ? extractPlanLines(plan.body, anchorStart, lineNumber) : "";
+		const sectionTitle = typeof body.sectionTitle === "string" && body.sectionTitle ? body.sectionTitle : lineNumber > 0 ? sectionTitleForLine(plan.body, anchorStart) : void 0;
+		const createdAtPlanVersion = Number.isFinite(body.createdAtPlanVersion) ? Number(body.createdAtPlanVersion) : plan.version;
+		const comment = {
+			id: crypto.randomUUID(),
+			lineNumber,
+			startLineNumber,
+			lineContent,
+			sectionTitle,
+			body: body.body,
+			status: "open",
+			createdAt: Date.now(),
+			createdAtPlanVersion,
+			replies: []
+		};
+		const updated = await plans.addComment(planId, comment);
+		if (!updated) return c.json({ error: "Plan not found" }, 404);
+		return c.json(updated, 201);
+	});
+	app.put("/api/plans/:id/comments/:commentId", async (c) => {
+		const { body, status } = await c.req.json();
+		const updated = await plans.updateComment(c.req.param("id"), c.req.param("commentId"), {
+			body,
+			status
+		});
+		if (!updated) return c.json({ error: "Plan or comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/plans/:id/comments/:commentId", async (c) => {
+		const updated = await plans.removeComment(c.req.param("id"), c.req.param("commentId"));
+		if (!updated) return c.json({ error: "Plan or comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.post("/api/plans/:id/comments/:commentId/replies", async (c) => {
+		const { body, role, model } = await c.req.json();
+		const reply = {
+			id: crypto.randomUUID(),
+			body,
+			createdAt: Date.now(),
+			role: role || (model ? "agent" : "user"),
+			model: model || void 0
+		};
+		const updated = await plans.addReply(c.req.param("id"), c.req.param("commentId"), reply);
+		if (!updated) return c.json({ error: "Plan or comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.put("/api/plans/:id/comments/:commentId/replies/:replyId", async (c) => {
+		const { body } = await c.req.json();
+		if (!body) return c.json({ error: "Body is required" }, 400);
+		const updated = await plans.updateReply(c.req.param("id"), c.req.param("commentId"), c.req.param("replyId"), body);
+		if (!updated) return c.json({ error: "Plan, comment, or reply not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/plans/:id/comments/:commentId/replies/:replyId", async (c) => {
+		const updated = await plans.removeReply(c.req.param("id"), c.req.param("commentId"), c.req.param("replyId"));
+		if (!updated) return c.json({ error: "Plan, comment, or reply not found" }, 404);
+		return c.json(updated);
+	});
+	app.post("/api/plans/:id/decision", async (c) => {
+		const planId = c.req.param("id");
+		const body = await c.req.json().catch(() => ({}));
+		const decision = body.decision;
+		if (decision !== "approved" && decision !== "rejected" && decision !== "changes-requested" && decision !== "comment-only") return c.json({ error: "decision must be one of: approved, rejected, changes-requested, comment-only" }, 400);
+		const decisionComment = typeof body.decisionComment === "string" ? body.decisionComment : void 0;
+		const mode = body?.mode === "comment-only" || body?.mode === "standard" ? body.mode : "standard";
+		const plan = await plans.setDecision(planId, decision, decisionComment);
+		if (!plan) return c.json({ error: "Plan not found" }, 404);
+		const openCommentCount = (plan.comments ?? []).filter((x) => x.status === "open").length;
+		const payload = planReviewSession.decide({
+			sentAt: Date.now(),
+			planId,
+			decision,
+			decisionComment: plan.decisionComment,
+			reviewXml: formatPlanReview(plan, { mode }),
+			openCommentCount,
+			plan,
+			mode
+		});
+		return c.json({
+			ok: true,
+			round: payload.round,
+			decision,
+			mode: payload.mode,
+			openCommentCount,
+			waiters: planReviewSession.snapshot().waiters
+		});
+	});
+	app.get("/api/plan-review/await", async (c) => {
+		const sinceRaw = c.req.query("sinceRound");
+		const sinceRound = sinceRaw !== void 0 && sinceRaw !== "" ? Number(sinceRaw) : void 0;
+		const requested = Number(c.req.query("timeoutMs")) || 25e3;
+		const timeoutMs = Math.min(Math.max(requested, 1e3), 5e4);
+		const result = await planReviewSession.await({
+			sinceRound: Number.isNaN(sinceRound) ? void 0 : sinceRound,
+			timeoutMs,
+			signal: c.req.raw.signal
+		});
+		return c.json(result);
+	});
+	app.get("/api/plan-review/status", (c) => {
+		return c.json(planReviewSession.snapshot());
+	});
+	app.post("/api/attachments", async (c) => {
+		const file = (await c.req.parseBody())["file"];
+		if (!file || !(file instanceof File)) return c.json({ error: "No file uploaded" }, 400);
+		try {
+			const storageDir = getProjectStorageDir();
+			const attachmentsDir = join(storageDir, "attachments");
+			await mkdir(attachmentsDir, { recursive: true });
+			const repoRoot = getRepoRoot();
+			await writeFile(join(storageDir, "repo_path.txt"), repoRoot, "utf-8");
+			const ext = extname(file.name) || ".png";
+			const filename = `pasted_image_${crypto.randomUUID()}${ext}`;
+			const absolutePath = join(attachmentsDir, filename);
+			const arrayBuffer = await file.arrayBuffer();
+			await writeFile(absolutePath, new Uint8Array(arrayBuffer));
+			return c.json({ url: `/api/attachments/${filename}` });
+		} catch (err) {
+			return c.json({ error: `Failed to save attachment: ${err.message}` }, 500);
+		}
+	});
+	app.get("/api/attachments/:filename", async (c) => {
+		const filename = c.req.param("filename");
+		const attachmentsDir = join(getProjectStorageDir(), "attachments");
+		const absolutePath = resolve(attachmentsDir, filename);
+		if (!absolutePath.startsWith(attachmentsDir)) return c.text("Forbidden", 403);
+		try {
+			const content = await readFile(absolutePath);
+			const contentType = MIME_TYPES[extname(absolutePath)] || "application/octet-stream";
+			return new Response(content, { headers: { "Content-Type": contentType } });
+		} catch {
+			return c.text("Attachment not found", 404);
+		}
+	});
+	app.get("/*", async (c) => {
+		let filePath = c.req.path;
+		if (filePath === "/") filePath = "/index.html";
+		const relativePath = filePath.slice(1);
+		if (!isSafePath(relativePath, clientDir)) return c.text("Forbidden", 403);
+		const fullPath = resolve(clientDir, relativePath);
+		try {
+			const content = await readFile(fullPath);
+			const contentType = MIME_TYPES[extname(fullPath)] || "application/octet-stream";
+			return new Response(content, { headers: { "Content-Type": contentType } });
+		} catch {
+			const indexContent = await readFile(join(clientDir, "index.html"));
+			return new Response(indexContent, { headers: { "Content-Type": "text/html" } });
+		}
+	});
+	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;
+	try {
+		const entries = await readdir(baseDir, { withFileTypes: true });
+		const now = Date.now();
+		const STALE_TIME = 336 * 60 * 60 * 1e3;
+		for (const entry of entries) if (entry.isDirectory()) {
+			const projectDir = join(baseDir, entry.name);
+			const repoPathFile = join(projectDir, "repo_path.txt");
+			let shouldDelete = false;
+			if (existsSync(repoPathFile)) try {
+				const repoPath = (await readFile(repoPathFile, "utf-8")).trim();
+				if (!repoPath || !existsSync(repoPath)) 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
+			});
+		}
+	} catch (err) {
+		console.error("Failed to cleanup stale projects:", err);
+	}
+}
+async function startServer(options) {
+	cleanupStaleProjects().catch((err) => {
+		console.error("Failed to clean up stale projects:", err);
+	});
+	let prMode = false;
+	if (options.prRef) {
+		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, void 0, void 0, void 0, prMode);
+	return new Promise((resolve) => {
+		serve({
+			fetch: app.fetch,
+			port: options.port,
+			hostname: options.host
+		}, (info) => {
+			resolve({
+				port: info.port,
+				prMode
+			});
+		});
+	});
+}
+//#endregion
+export { buildGitDiffArgs as a, printHelp as c, validateEnvironment as i, loadSettings as n, intoShowMode as o, runTerminalDiff as r, parseDiffOptions as s, startServer as t };