@diffohq/diffo 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,4553 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
+import { chmodSync, closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, watch, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs, promisify } from "node:util";
+import { readFile } from "node:fs/promises";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { stream, streamSSE } from "hono/streaming";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/agentSession.ts
+/** A row whose leading token is a shell is never the session. Tested on the FIRST
+* token only: under Claude Code the transient `zsh -c` carries
+* `~/.claude/shell-snapshots/…` in its arguments, which would match HARNESS. */
+const SHELL = /^-?(?:\/[^ ]*\/)?(?:sh|bash|zsh|fish|dash|ksh|csh|tcsh)(?:\s|$)/;
+const HARNESS = /claude|cursor|codex|copilot|windsurf|zed|aider|goose|cline|amp/i;
+function pickSessionAncestor(ancestors) {
+	for (const row of ancestors) {
+		const command = row.command.trim();
+		if (SHELL.test(command)) continue;
+		if (HARNESS.test(command)) return row.pid;
+	}
+	return null;
+}
+function readRow(pid) {
+	try {
+		const ppid = Number.parseInt(execFileSync("ps", [
+			"-o",
+			"ppid=",
+			"-p",
+			String(pid)
+		], { encoding: "utf-8" }).trim(), 10);
+		const command = execFileSync("ps", [
+			"-o",
+			"command=",
+			"-p",
+			String(pid)
+		], { encoding: "utf-8" }).trim();
+		if (!Number.isFinite(ppid) || command === "") return null;
+		return {
+			pid,
+			ppid,
+			command
+		};
+	} catch {
+		return null;
+	}
+}
+function readAncestors(startPid, rowFor = readRow, maxDepth = 12) {
+	const rows = [];
+	let pid = startPid;
+	for (let depth = 0; depth < maxDepth && pid > 1; depth++) {
+		const row = rowFor(pid);
+		if (!row) break;
+		rows.push(row);
+		if (row.ppid === pid) break;
+		pid = row.ppid;
+	}
+	return rows;
+}
+function detectSessionPid() {
+	if (process.platform === "win32") return null;
+	try {
+		return pickSessionAncestor(readAncestors(process.ppid));
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/shared/review.ts
+const THREAD_INTENTS = ["fix", "question"];
+/** The thread was started by the agent (its opening message is the agent's).
+* Drives rendering — avatar, head label — and never changes. */
+function startedByAgent(thread) {
+	return thread.messages[0]?.author === "agent";
+}
+/** Agent-started with nothing of the reviewer's in it. Only these are excluded
+* from the reviewer's counts, Send, and the finish flush — the moment the
+* reviewer writes a reply into an agent thread, it carries their feedback and
+* moves exactly like a thread they opened themselves. */
+function untouchedAgentVoice(thread) {
+	return startedByAgent(thread) && !thread.messages.some((m) => m.author === "reviewer");
+}
+/**
+* Feedback the reviewer is still owed an answer on — the delivery queue's contents,
+* derived rather than remembered, so a restart cannot drop an Ask nobody collected.
+* The cuts: handed over at all; not already ruled unanswered by a closed batch; not
+* deliberately withheld; and the reviewer spoke last.
+*/
+function undeliveredThreadIds(threads) {
+	return threads.filter((t) => (t.state === "sent" || t.state === "addressed") && t.unanswered !== true && t.withheld !== true && t.messages.at(-1)?.author === "reviewer").sort((a, b) => (a.sentAt ?? "").localeCompare(b.sentAt ?? "")).map((t) => t.id);
+}
+const REVIEW_VERDICTS = [
+	"comment",
+	"approve",
+	"request-changes"
+];
+const EMPTY_REVIEW = {
+	version: 1,
+	threads: []
+};
+/**
+* Threads this changeset still owns, and the ones it has left behind. A thread is
+* *active* while the diff still has somewhere to put it — its hunk, or failing that
+* its file — and a changeset-level note lives as long as the changeset has files.
+*
+* Past threads are hidden, never deleted: a stash or a branch switch empties the diff
+* for a minute and must not destroy a thread.
+*/
+function threadsInChangeset(files, threads) {
+	const hunkIds = new Set(files.flatMap((f) => f.hunks.map((h) => h.id)));
+	const paths = new Set(files.flatMap((f) => f.oldPath ? [f.path, f.oldPath] : [f.path]));
+	const lives = (thread) => {
+		const anchor = thread.anchor;
+		if (anchor.kind === "changeset") return files.length > 0;
+		if (anchor.kind === "file") return paths.has(anchor.path);
+		return hunkIds.has(anchor.hunkId) || paths.has(anchor.path);
+	};
+	const active = [];
+	const past = [];
+	for (const thread of threads) (lives(thread) ? active : past).push(thread);
+	return {
+		active,
+		past
+	};
+}
+function describeAnchor(anchor) {
+	if (anchor.kind === "changeset") return "the whole changeset";
+	if (anchor.kind === "file") return anchor.path;
+	return `${anchor.path}:${anchor.line} (${anchor.side} side)`;
+}
+//#endregion
+//#region src/server/prompt.ts
+function snapshotHunk(changeset, hunkId) {
+	for (const file of changeset.files) {
+		const hunk = file.hunks.find((h) => h.id === hunkId);
+		if (!hunk) continue;
+		const marker = {
+			add: "+",
+			del: "-",
+			context: " "
+		};
+		return hunk.lines.map((l) => marker[l.kind] + l.text).join("\n");
+	}
+	return null;
+}
+const NPX = `npx -y @diffohq/diffo`;
+/** This checkout's root — `src/server/prompt.ts` → up two. */
+const CHECKOUT_ROOT = fileURLToPath(new URL("../..", import.meta.url)).replace(/\/$/, "");
+const IS_DEV = process.env.ENV === "development";
+/** Running the CLI straight from a checkout. Absolute on both halves — the agent
+* runs it from inside the repo under review, hence the tsx *binary* rather than
+* `node --import tsx`, which resolves its loader against the cwd. The
+* `ENV=development` prefix travels with the invocation so the server a dev skill
+* starts speaks the same dev CLI back. */
+function devCliFor(checkoutRoot) {
+	return `ENV=development ${checkoutRoot}/node_modules/.bin/tsx ${checkoutRoot}/src/cli.ts`;
+}
+const CLI = IS_DEV ? devCliFor(CHECKOUT_ROOT) : NPX;
+function buildCliCommands(cli) {
+	return {
+		open: cli,
+		poll: `${cli} poll`,
+		reply: `${cli} reply <threadId> --message "<your reply>"`,
+		comment: `${cli} comment [<file>] [--line <line>] --message "<comment>"`,
+		guide: `${cli} comment --message "<what the change does>"`,
+		end: `${cli} end`,
+		setup: `${cli} setup`
+	};
+}
+const CLI_COMMANDS = buildCliCommands(CLI);
+/** Drift-tested against package.json's `repository` in prompt.test.ts. */
+const SKILL_REPO = "DiffoHQ/diffo";
+function buildInstallSkill(isDev, checkoutRoot, global = true) {
+	if (isDev) return `cd ${checkoutRoot} && pnpm dev:skill${global ? " --global" : ""}`;
+	return `npx skills add ${SKILL_REPO} --skill diffo${global ? " -g" : ""}`;
+}
+const INSTALL_SKILL = {
+	global: buildInstallSkill(IS_DEV, CHECKOUT_ROOT, true),
+	project: buildInstallSkill(IS_DEV, CHECKOUT_ROOT, false)
+};
+/**
+* Payloads must stand alone: agents join without the skill (the invite modal's
+* paste, a fresh session, a compacted context), so every instruction to poll
+* restates how to hold the poll — attended, never detached. Mirrors the skill.
+*/
+const POLL_STANCE = "a tracked background task if your harness has one, the foreground if not — never a detached process";
+const JOIN_PROMPT = `join the diffo review: run \`${CLI_COMMANDS.poll}\` (${POLL_STANCE}) and follow the JSON payload it prints — each payload carries its own instructions`;
+function nextStepFor(kind, actionable) {
+	if (kind === "finish" && actionable === 0) return `Nothing to act on — run \`${CLI_COMMANDS.poll}\` again to keep listening (${POLL_STANCE}); the reviewer may follow up.`;
+	return `${kind === "finish" ? "The reviewer is done reading — work the whole batch. " : ""}Act on each thread, reply with \`${CLI_COMMANDS.reply}\`, then run \`${CLI_COMMANDS.poll}\` again to keep listening.`;
+}
+const ACK_NEXT_STEP = {
+	reply: `When every thread is handled, run \`${CLI_COMMANDS.poll}\` again to keep listening (${POLL_STANCE}).`,
+	comment: `It's in the review as your comment, labeled as yours — the reviewer replies to take it up, or resolves it. Continue with the review threads, then run \`${CLI_COMMANDS.poll}\`.`,
+	end: "Detached. Do not reopen or re-poll this review unless the user asks — deliver anything remaining directly in the conversation."
+};
+/**
+* The guide doctrine — the one agent comment that orients a cold reader.
+* Stated once and interpolated into every surface that teaches it (the skill,
+* `help agent`, the open-time nudge below), the same way POLL_STANCE keeps the
+* poll rules aligned: the surfaces phrase it at different lengths, but these
+* invariants cannot drift apart.
+*/
+const GUIDE = {
+	/** When one is warranted — and that silence is a valid outcome. */
+	when: "multi-file, structural, or subtle — skip when the diff explains itself",
+	/** What it contains. */
+	what: "one sentence on what the change does, plus a small ```mermaid diagram if a picture explains the shape better than words",
+	/** The line it must not cross. */
+	stance: "Orient reading, never pre-review: no verdicts, nothing is \"fine\"",
+	/** Staleness: the guide is a thread, so updates land under it. */
+	update: "reply to your own guide thread with a short update"
+};
+/**
+* Printed by `diffo` (open) to a piped stdout when the review has no guide yet.
+* The skill teaches the same step, but this line is what an agent WITHOUT the
+* skill sees — payloads and command output must stand alone (see POLL_STANCE).
+*/
+function guideNudge(hasGuide) {
+	if (hasGuide) return null;
+	return `orient the reviewer before sharing the URL, if this changeset needs it (${GUIDE.when}): post a guide — one comment on the whole changeset: ${GUIDE.what}: \`${CLI_COMMANDS.guide}\` (no file, so it anchors to the changeset). ${GUIDE.stance}.`;
+}
+/**
+* Printed to stderr when a poll takes the review over and the review already
+* carries a guide: the new agent inherits it as orientation and updates it in
+* place — a second guide would give the reviewer two.
+*/
+function guideInherit(threadId) {
+	return `diffo: this review already carries the previous agent's guide (thread ${threadId}).\nRead it, and if your changes reshape the changeset update it by replying to it\n(\`${CLI} reply ${threadId} -m "…"\`) rather than posting a second guide.\n`;
+}
+const INTENT_LABEL = {
+	question: "question",
+	fix: "issue"
+};
+const INTENT_CONTRACT = {
+	question: "- `question` threads want an answer, not an edit. Reply in the thread; change no code for them unless the reviewer asks.",
+	fix: "- `issue` threads want a code change. Address each one, or push back in the thread with your reasoning."
+};
+const UNLABELED_CONTRACT = "- Unlabeled threads: judge from the text — a question wants an answer, not an edit.";
+/** The closing note is the reviewer summing up, so it earns an answer even when it
+* asks nothing — a note with no reply is the review's one dead end. */
+const CLOSING_CONTRACT = "- The closing note speaks for the whole review: read it first, and reply to it — briefly if it only sums up, in full if it asks something.";
+function intentContract(threads) {
+	const present = new Set(threads.filter((t) => !t.closingNote).map((t) => t.intent));
+	const lines = THREAD_INTENTS.filter((i) => present.has(i)).map((i) => INTENT_CONTRACT[i]);
+	if (present.has(void 0)) lines.push(UNLABELED_CONTRACT);
+	if (threads.some((t) => t.closingNote)) lines.push(CLOSING_CONTRACT);
+	return lines;
+}
+function replyProtocol(threads) {
+	const batchNote = threads.length > 1 ? "\nRead every thread before you start editing — threads can touch the same\ncode, and an edit for one can move what another is anchored to.\n" : "";
+	const answeredNote = threads.some((t) => t.messages.at(-1)?.author === "agent") ? ["   - Some threads end with your own earlier reply — if nothing new was asked since, don't reply to them again."] : [];
+	return `## How to respond
+
+Diffo is running locally; talk to it through its CLI.
+${batchNote}
+For each thread above:
+
+1. Act on it.
+${[...intentContract(threads).map((line) => `   ${line}`), ...answeredNote].join("\n")}
+2. Reply to the thread (concise, addressed to the reviewer, no preamble):
+
+   ${CLI_COMMANDS.reply}
+
+   (a long reply can be piped instead: pipe it to \`${CLI} reply <threadId>\`)
+
+   A fix reply says what changed and where (\`file:line\`) — don't paste the
+   diff; the reviewer's browser shows your edits live. Before saying something
+   is fixed, verify it the cheapest honest way (run the relevant test, re-read
+   the change) and mention what you checked.
+   Reply as soon as a thread is handled; don't save replies for the end.
+   Replies and comment threads render GitHub-flavored markdown, and a
+   \`\`\`mermaid fence renders as a diagram — use one when a flow, sequence,
+   or state picture explains the change better than prose. Keep it small
+   (roughly ten nodes); it renders inside a narrow thread card.
+3. If you notice something worth a comment of its own — a potential issue,
+   or context that helps the reviewer read — start a thread:
+
+   ${CLI_COMMANDS.comment}
+
+   Anchor it to a line (--line), a file, or the whole changeset (no file).
+   It appears in the review in your voice and never counts as the reviewer's
+   feedback: they reply to take it up, or resolve it. Spend these sparingly —
+   an agent that annotates everything gets skimmed.
+4. When every thread is handled, run \`${CLI_COMMANDS.poll}\` again to wait
+   for the reviewer's next feedback — ${POLL_STANCE}.
+
+Rules:
+
+- Change only what these threads ask about — the reviewer is mid-read, and an
+  unrelated edit moves the diff under them. If a correct fix has to touch other
+  code, say so in the thread (or in a comment thread of yours) before doing it.
+- Each "commented change" above was frozen when the comment was written —
+  re-read the current file before editing; the code may have moved since.
+- Your code edits are detected automatically and the reviewer's diff updates
+  live. Resolving a thread is the reviewer's call, never yours.`;
+}
+const FRAME_FILE_CAP = 40;
+function fileLine(file) {
+	const letter = {
+		added: "A",
+		modified: "M",
+		deleted: "D",
+		renamed: "R"
+	}[file.status];
+	return file.status === "renamed" && file.oldPath ? `- R ${file.oldPath} → ${file.path}` : `- ${letter} ${file.path}`;
+}
+function specLine(changeset) {
+	const spec = changeset.spec.kind === "working-tree" ? "the working tree against HEAD" : `the working tree against merge-base(\`${changeset.spec.base}\`, HEAD)`;
+	const { files, additions, deletions } = changeset.stats;
+	return `The changeset under review: ${spec} — ${files} file${files === 1 ? "" : "s"}, +${additions} −${deletions}.`;
+}
+function changesetFrame(changeset) {
+	const listed = changeset.files.slice(0, FRAME_FILE_CAP).map(fileLine);
+	if (changeset.files.length > FRAME_FILE_CAP) listed.push(`- … and ${changeset.files.length - FRAME_FILE_CAP} more`);
+	return [
+		"## The changeset under review",
+		"",
+		specLine(changeset),
+		"",
+		...listed
+	].join("\n");
+}
+const SIBLING_CAP = 10;
+function siblingLines(siblings) {
+	if (siblings.length === 0) return null;
+	const lines = siblings.slice(0, SIBLING_CAP).map((t) => {
+		const first = t.messages[0]?.text.split("\n")[0]?.slice(0, 100) ?? "";
+		return `- ${describeAnchor(t.anchor)} — "${first}"`;
+	});
+	if (siblings.length > SIBLING_CAP) lines.push(`- … and ${siblings.length - SIBLING_CAP} more`);
+	return [
+		"## Other review threads (context only — do not act on them here)",
+		"",
+		...lines
+	].join("\n");
+}
+const SNAPSHOT_LINE_CAP = 25;
+function threadBlock(thread, index) {
+	const label = startedByAgent(thread) ? " [your comment — the reviewer replied]" : thread.closingNote ? " [their closing note on the whole review]" : thread.intent ? ` [${INTENT_LABEL[thread.intent]}]` : "";
+	const again = thread.unanswered ? " — YOU NEVER ANSWERED THIS" : "";
+	const parts = [`### Thread ${index + 1}${label} — ${describeAnchor(thread.anchor)}${again}`, `id: ${thread.id}`];
+	if (thread.codeContext) {
+		const lines = thread.codeContext.split("\n");
+		parts.push("The commented change:", "```diff", ...lines.slice(0, SNAPSHOT_LINE_CAP), "```");
+		if (lines.length > SNAPSHOT_LINE_CAP) {
+			const where = thread.anchor.kind === "changeset" ? "the file" : `\`${thread.anchor.path}\``;
+			parts.push(`(… and ${lines.length - SNAPSHOT_LINE_CAP} more snapshot lines — read the current ${where} instead)`);
+		}
+	}
+	parts.push("Messages:", ...thread.messages.map((m) => `- ${m.author}: ${m.text.replace(/\n/g, "\n  ")}`));
+	return parts.join("\n");
+}
+function buildThreadPrompt(thread, ctx) {
+	const siblings = siblingLines(ctx.siblings ?? []);
+	return [
+		`A reviewer is reading your changes in \`${ctx.repo.name}\` (branch \`${ctx.repo.branch}\`) and sent you this review thread.`,
+		"",
+		...ctx.changeset ? [specLine(ctx.changeset), ""] : [],
+		threadBlock(thread, 0),
+		"",
+		...siblings ? [siblings, ""] : [],
+		replyProtocol([thread]),
+		""
+	].join("\n");
+}
+function buildCoalescedPrompt(threads, ctx) {
+	const siblings = siblingLines(ctx.siblings ?? []);
+	return [
+		`The reviewer sent new messages on ${threads.length} review threads in \`${ctx.repo.name}\` (branch \`${ctx.repo.branch}\`).`,
+		"",
+		...ctx.changeset ? [specLine(ctx.changeset), ""] : [],
+		...threads.map((t, i) => `${threadBlock(t, i)}\n`),
+		...siblings ? [siblings, ""] : [],
+		replyProtocol(threads),
+		""
+	].join("\n");
+}
+function buildFinishPrompt(threads, ctx, coverage) {
+	const repo = ctx.repo;
+	const sent = threads.filter((t) => t.state === "sent");
+	const closing = sent.find((t) => t.closingNote);
+	const actionable = closing ? [closing, ...sent.filter((t) => t !== closing)] : sent;
+	const changed = coverage.changedFiles ?? [];
+	const commented = coverage.commentedUnread ?? [];
+	const filtered = coverage.filteredOut ?? [];
+	const skipped = [
+		changed.length > 0 ? ` Changed after the reviewer read them (their read marks were revoked): ${changed.join(", ")}.` : "",
+		commented.length > 0 ? ` Commented on but not marked read: ${commented.join(", ")}.` : "",
+		filtered.length > 0 ? ` Deliberately out of scope — hidden by a filter and never read: ${filtered.join(", ")}.` : "",
+		coverage.skippedFiles.length > 0 ? ` Not marked read: ${coverage.skippedFiles.join(", ")}.` : ""
+	].join("");
+	const files = coverage.totalFiles !== void 0 && coverage.totalFiles > 0 ? `${coverage.viewedFiles ?? 0}/${coverage.totalFiles} files read, ` : "";
+	const verdictLine = coverage.verdict === "approve" ? "Verdict: **approved** — the reviewer is happy for this changeset to proceed." : coverage.verdict === "request-changes" ? "Verdict: **changes requested** — do not treat this review as done until the threads below are addressed." : null;
+	const noteLines = coverage.note === void 0 ? [] : closing ? ["Their closing note is Thread 1 below — answer it there, like any other thread."] : ["Their closing note:", ...coverage.note.split("\n").map((l) => `> ${l}`)];
+	const owed = actionable.filter((t) => t.unanswered);
+	const owedLines = owed.length > 0 ? [
+		`${owed.length} of the threads below you were already given once, and never`,
+		"replied to. They are marked. Answer those first — a reply, or a",
+		"reason you are not acting; going quiet again is the one thing that",
+		"leaves the reviewer with nothing to do.",
+		""
+	] : [];
+	const parts = [
+		`A reviewer finished reading your changes in \`${repo.name}\` (branch \`${repo.branch}\`).`,
+		"",
+		...verdictLine ? [verdictLine, ""] : [],
+		...noteLines.length > 0 ? [...noteLines, ""] : [],
+		...ctx.changeset ? [changesetFrame(ctx.changeset), ""] : [],
+		`Coverage: ${files}${coverage.viewedHunks}/${coverage.totalHunks} hunks read.${skipped}`,
+		"",
+		...owedLines
+	];
+	if (coverage.skippedFiles.length > 0) parts.push("The reviewer left the not-marked-read files unread. If any of them hide", "a risky or subtle change you made, say so in a comment thread", `(\`${CLI_COMMANDS.comment}\`) — the reviewer replies to take it up, or resolves it.`, "");
+	if (actionable.length === 0) parts.push("No open review threads — nothing to act on. Run", `\`${CLI_COMMANDS.poll}\` again to keep listening (${POLL_STANCE});`, "the reviewer may follow up.", "");
+	else parts.push(`${actionable.length} review thread${actionable.length === 1 ? "" : "s"} to act on:`, "", ...actionable.map((t, i) => `${threadBlock(t, i)}\n`), replyProtocol(actionable), "");
+	return parts.join("\n");
+}
+//#endregion
+//#region src/cliArgs.ts
+const HELP_TEXT = `diffo — review a changeset the way you'd read a book
+
+Usage: diffo [options]          open (or resume) the review for this repo
+       diffo <command> [...]    manage the server, or talk to the review
+       diffo help [command]     show help for a command
+
+For the reviewer:
+  status             Show this repo's review server, if one is running
+                     (--json for a machine-readable answer)
+  stop               Stop this repo's review server
+  setup              Register diffo with the coding agents on this machine
+                     (Claude Code, Cursor, VS Code, Copilot, and the shared
+                     ~/.agents skills dir read by Codex, Gemini, Amp, Goose, …)
+
+For the agent (the AI that wrote the change):
+  poll               Wait for the reviewer's feedback (blocking long-poll;
+                     prints one JSON payload; safe to re-run any time)
+  reply <threadId>   Post a reply to a review thread
+                     (--message "<text>", or pipe the text on stdin)
+  comment [<file>]   Start a comment thread as the agent — on a line (--line),
+                     a file, or (with no file) the whole changeset; the
+                     reviewer replies to take it up, or resolves it
+  end                Detach from the review politely
+  help agent         The agent's whole protocol on one page
+
+Options (for opening the review):
+  --base <branch>    Review everything since forking from <branch>
+                     (default: working tree vs HEAD)
+  -p, --port <port>  Port to serve on (default: the port this repo last used,
+                     else the first free one)
+  --no-open          Don't open the browser automatically
+  --foreground       Run the server in this terminal instead of leaving a
+                     background one behind (Ctrl-C stops it)
+  -v, --version      Show version
+  -h, --help         Show this help
+
+Examples:
+  diffo                        open the review for this repo in the browser
+  diffo --base main            review everything since forking from main
+  diffo status                 is a server running here, and where?
+  diffo reply t-3 -m "fixed"   answer a review thread (agent side)
+
+Feedback lives in the review, not in any process: diffo, poll, status, stop,
+and setup are all safe to re-run after an interruption.`;
+const VERB_HELP = {
+	agent: `diffo help agent — the agent's whole protocol on one page
+
+You are the agent that wrote the change; a human reads it live in their
+browser. Diffo carries their feedback to you and your replies back inline.
+Poll payloads carry their own instructions — this page is the map that
+survives when context does not.
+
+The loop:
+
+1. Open: run \`diffo --no-open\` from inside the repo. It returns straight
+   away, leaving a background server watching the working tree. Never open a
+   browser at the reviewer — end your message with the printed URL instead,
+   and keep ending every message with it while you stay attached.
+2. Guide (only when the changeset needs it — ${GUIDE.when}): before sharing
+   the URL, post ONE comment on the whole changeset (\`diffo comment -m "…"\`,
+   no file): ${GUIDE.what}.
+   ${GUIDE.stance}. If the changeset later shifts under the guide,
+   ${GUIDE.update}.
+3. Listen: run \`diffo poll\` — it blocks until the reviewer acts, then prints
+   one JSON payload naming the threads to act on. Run it attended:
+   ${POLL_STANCE}.
+   Killed or timed out? Re-run it; feedback is held in the review, not the
+   poll.
+4. Act: \`[issue]\` threads want a code change; \`[question]\` threads want an
+   answer in the reply and no edit. Your edits reach the reviewer live.
+5. Reply: \`diffo reply <threadId> --message "<text>"\` (pipe long replies on
+   stdin) — concise, addressed to the reviewer. Markdown renders; a
+   \`\`\`mermaid fence draws a diagram.
+6. Comment (sparingly): \`diffo comment [<file>] [--line <n>] -m "<text>"\`
+   starts a thread in your voice — a concern, or context that helps the read.
+7. Poll again only when the whole batch is handled — a new poll tells the
+   reviewer you are done with the previous one.
+8. Detach: run \`diffo end\` when the review is over or the user moves on.
+
+Rules:
+- Change only what the threads ask about — the reviewer is mid-read, and an
+  unrelated edit moves the diff under them.
+- One attached agent at a time: the newest poll carries the review; don't
+  re-poll to take it back from another session — tell the user instead.
+- Resolving a thread is the reviewer's call, never yours.`,
+	poll: `diffo poll — wait for the reviewer's feedback
+
+Usage: diffo poll
+
+Blocks (streaming whitespace heartbeats) until the reviewer acts, then prints
+one JSON payload naming the review threads to act on, and exits. Run it
+attended — a tracked background task or the foreground, never detached: a
+payload that reaches a process nobody is listening to never reaches you.
+Safe to re-run any time: feedback is held in the review itself, so
+nothing is lost when a poll is killed or times out — the next poll gets it.
+
+Output: one JSON object, e.g.
+  {"status":"feedback","threadIds":["t-3"],"prompt":"…what to do…"}
+
+Example:
+  diffo poll`,
+	reply: `diffo reply — post a reply to a review thread
+
+Usage: diffo reply <threadId> --message "<text>"
+       … | diffo reply <threadId>            (long replies: pipe on stdin)
+
+Thread ids arrive in poll payloads. Each run posts one message, so don't
+re-run a reply that succeeded.
+Messages render GitHub-flavored markdown; a \`\`\`mermaid fence renders as a
+diagram in the review.
+
+Output: {"ok":true,"threadId":"t-3","state":"…","next_step":"…"}
+
+Example:
+  diffo reply t-3 --message "fixed — the guard now covers the empty case"`,
+	comment: `diffo comment — start a comment thread as the agent
+
+Usage: diffo comment [<file>] [--line <n>] --message "<text>"
+       … | diffo comment [<file>] [--line <n>]  (long comments: pipe on stdin)
+
+Anchors to a line (--line), a file, or — with no file — the whole changeset.
+A potential issue, or context that helps the reviewer read: either way it is
+one thread, labeled as yours, and it never counts as the reviewer's feedback
+until they reply into it — then it is theirs to send — or they resolve it.
+Spend these sparingly — an agent that annotates everything gets skimmed.
+Messages render GitHub-flavored markdown; a \`\`\`mermaid fence renders as a
+diagram in the review.
+
+Output: {"ok":true,"threadId":"t-1","next_step":"…"}
+
+Example:
+  diffo comment src/auth.ts --line 42 --message "this branch is unreachable"`,
+	end: `diffo end — detach from the review politely
+
+Usage: diffo end
+
+Ends YOUR attachment only: if another session is the attached agent it does
+nothing, and says so. Safe to re-run.
+
+Output: {"ok":true,"next_step":"…"}
+
+Example:
+  diffo end`,
+	status: `diffo status — show this repo's review server, if one is running
+
+Usage: diffo status [--json]
+
+Prints the changeset summary, the server (port, pid, version), and the review
+URL. Exits 0 when a server is running, 1 when none is. Safe to re-run.
+
+--json prints one JSON object instead, e.g.
+  {"running":true,"port":4949,"pid":123,"version":"0.0.1","url":"http://localhost:4949"}
+  {"running":false}
+
+Example:
+  diffo status --json`,
+	stop: `diffo stop — stop this repo's review server
+
+Usage: diffo stop
+
+Asks the server to shut down cleanly (falling back to a signal if it lingers)
+and clears its registration. Safe to re-run: stopping nothing is a success,
+and the review itself survives — the next \`diffo\` picks it back up.
+
+Example:
+  diffo stop`,
+	setup: `diffo setup — register diffo with the coding agents on this machine
+
+Usage: diffo setup
+
+Detects Claude Code, Cursor, VS Code, and Copilot CLI, and registers diffo
+with each so they know when and how to open a review. Also installs into
+~/.agents/skills — the cross-tool skills directory read by Codex, Gemini CLI,
+Amp, Goose, OpenCode, and others. Safe to re-run: already-registered clients
+are left as they are, and opening a review keeps installed skills fresh
+automatically after upgrades.
+
+Example:
+  diffo setup`
+};
+function helpFor(topic) {
+	return topic && VERB_HELP[topic] || HELP_TEXT;
+}
+const VERBS = /* @__PURE__ */ new Set([
+	"poll",
+	"reply",
+	"comment",
+	"end",
+	"setup",
+	"status",
+	"stop"
+]);
+function editDistance(a, b) {
+	const dp = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i++) {
+		let diagonal = dp[0];
+		dp[0] = i;
+		for (let j = 1; j <= b.length; j++) {
+			const above = dp[j];
+			dp[j] = Math.min(above + 1, dp[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+			diagonal = above;
+		}
+	}
+	return dp[b.length];
+}
+/** The closest command within two edits — one typo away, not a different word. */
+function nearestVerb(input) {
+	let best = null;
+	let bestDistance = 3;
+	for (const verb of [...VERBS, "help"]) {
+		const distance = editDistance(input.toLowerCase(), verb);
+		if (distance < bestDistance) {
+			bestDistance = distance;
+			best = verb;
+		}
+	}
+	return best;
+}
+function unknownCommand(input) {
+	const suggestion = nearestVerb(input);
+	return {
+		kind: "error",
+		message: `unknown command '${input}'${suggestion ? ` — did you mean '${suggestion}'?` : ""}`
+	};
+}
+function parseHelp(rest) {
+	const topic = rest[0];
+	if (rest.length > 1) return {
+		kind: "error",
+		message: "help takes at most one command"
+	};
+	if (topic === void 0 || topic === "help") return { kind: "help" };
+	if (topic !== "agent" && !VERBS.has(topic)) return unknownCommand(topic);
+	return {
+		kind: "help",
+		topic
+	};
+}
+/** `parseInt` would take '80.5' and '80abc' as 80; a number is all digits or nothing. */
+function parseWholeNumber(raw) {
+	return /^\d+$/.test(raw) ? Number.parseInt(raw, 10) : null;
+}
+/**
+* Mirrors the characters git itself forbids in a ref name, plus a leading dash —
+* which would be handed to git in argument position (e.g.
+* `merge-base --upload-pack=… HEAD`). Catching these here turns a cryptic git
+* failure into a plain diffo error.
+*/
+function isInvalidBranchName(name) {
+	for (const ch of name) {
+		const code = ch.codePointAt(0) ?? 0;
+		if (code < 32 || code === 127) return true;
+	}
+	return /[\s~^:?*[\\]|\.\.|@\{|^[-.]|[/.]$|\.lock$/.test(name);
+}
+/** `parseArgs` throws on an unknown flag; turn that into a `CliCommand` error. */
+function tryParse(run) {
+	try {
+		return {
+			ok: true,
+			value: run()
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			message: err.message.split(".")[0] ?? "invalid arguments"
+		};
+	}
+}
+function parseCliArgs(argv) {
+	if (argv[0] !== void 0 && !argv[0].startsWith("-")) {
+		if (argv[0] === "help") return parseHelp(argv.slice(1));
+		if (VERBS.has(argv[0])) return parseVerb(argv[0], argv.slice(1));
+		return unknownCommand(argv[0]);
+	}
+	const parsed = tryParse(() => parseArgs({
+		args: argv,
+		options: {
+			port: {
+				type: "string",
+				short: "p"
+			},
+			base: { type: "string" },
+			"no-open": {
+				type: "boolean",
+				default: false
+			},
+			foreground: {
+				type: "boolean",
+				default: false
+			},
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			version: {
+				type: "boolean",
+				short: "v"
+			}
+		}
+	}));
+	if (!parsed.ok) return {
+		kind: "error",
+		message: parsed.message
+	};
+	const { values } = parsed.value;
+	if (values.help) return { kind: "help" };
+	if (values.version) return { kind: "version" };
+	let port;
+	if (values.port !== void 0) {
+		const parsedPort = parseWholeNumber(values.port);
+		if (parsedPort === null || parsedPort < 1 || parsedPort > 65535) return {
+			kind: "error",
+			message: `'${values.port}' is not a valid port`
+		};
+		port = parsedPort;
+	}
+	if (values.base !== void 0 && values.base.trim() === "") return {
+		kind: "error",
+		message: "--base needs a branch name"
+	};
+	if (values.base !== void 0 && isInvalidBranchName(values.base)) return {
+		kind: "error",
+		message: `'${values.base}' is not a valid branch name`
+	};
+	return {
+		kind: "run",
+		spec: values.base ? {
+			kind: "branch",
+			base: values.base
+		} : { kind: "working-tree" },
+		port,
+		open: !values["no-open"],
+		foreground: values.foreground === true
+	};
+}
+function parseVerb(verb, rest) {
+	const parsed = tryParse(() => parseArgs({
+		args: rest,
+		allowPositionals: true,
+		options: {
+			message: {
+				type: "string",
+				short: "m"
+			},
+			line: { type: "string" },
+			json: { type: "boolean" },
+			help: {
+				type: "boolean",
+				short: "h"
+			}
+		}
+	}));
+	if (!parsed.ok) return {
+		kind: "error",
+		message: parsed.message
+	};
+	const { values, positionals } = parsed.value;
+	if (values.help) return {
+		kind: "help",
+		topic: verb
+	};
+	if (values.json && verb !== "status") return {
+		kind: "error",
+		message: `'${verb}' takes no --json`
+	};
+	if (verb === "poll" || verb === "end" || verb === "setup" || verb === "status" || verb === "stop") {
+		if (positionals.length > 0) return {
+			kind: "error",
+			message: `'${verb}' takes no arguments`
+		};
+		if (values.message !== void 0 || values.line !== void 0) return {
+			kind: "error",
+			message: `'${verb}' takes no options`
+		};
+		if (verb === "status") return {
+			kind: "status",
+			json: values.json === true
+		};
+		return { kind: verb };
+	}
+	if (verb === "reply") {
+		const threadId = positionals[0];
+		if (!threadId) return {
+			kind: "error",
+			message: "reply needs a thread id"
+		};
+		if (positionals.length > 1) return {
+			kind: "error",
+			message: "pass the reply with --message or on stdin, not as an argument"
+		};
+		if (values.line !== void 0) return {
+			kind: "error",
+			message: "reply takes no --line"
+		};
+		return {
+			kind: "reply",
+			threadId,
+			message: values.message ?? null
+		};
+	}
+	const file = positionals[0] ?? null;
+	if (positionals.length > 1) return {
+		kind: "error",
+		message: "pass the comment with --message or on stdin, not as an argument"
+	};
+	let line = null;
+	if (values.line !== void 0) {
+		line = parseWholeNumber(values.line);
+		if (line === null || line < 1) return {
+			kind: "error",
+			message: `'${values.line}' is not a valid line number`
+		};
+	}
+	if (line !== null && file === null) return {
+		kind: "error",
+		message: "a --line needs a file to anchor to"
+	};
+	return {
+		kind: "comment",
+		file,
+		line,
+		message: values.message ?? null
+	};
+}
+//#endregion
+//#region src/server/git.ts
+const MAX_BUFFER = 52428800;
+const SNIFF_BYTES = 8192;
+/** Largest untracked file whose content the diff will inline. Deliberately not
+* `MAX_BUFFER`: that bounds a subprocess's stdout, and the two limits move for
+* different reasons. */
+const MAX_INLINE_BYTES = 2097152;
+const DIFF_FLAGS = [
+	"--no-ext-diff",
+	"--no-color",
+	"-M"
+];
+function git(root, args) {
+	return execFileSync("git", args, {
+		cwd: root,
+		encoding: "utf-8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		maxBuffer: MAX_BUFFER
+	});
+}
+const execFileAsync = promisify(execFile);
+/**
+* The same call, off the event loop. Every `git` here is the process waiting on a
+* child, which `execFileSync` spends blocking the loop — one recompute on a
+* 17,639-directory repo measured ~700ms of answering nothing.
+*
+* The sync twins stay: startup builds the first changeset before anything is
+* served, where blocking is free and an `await` in a constructor is not.
+*/
+async function gitAsync(root, args) {
+	const { stdout } = await execFileAsync("git", args, {
+		cwd: root,
+		encoding: "utf-8",
+		maxBuffer: MAX_BUFFER
+	});
+	return stdout;
+}
+function findRepoRoot(cwd) {
+	try {
+		return git(cwd, ["rev-parse", "--show-toplevel"]).trim();
+	} catch {
+		return null;
+	}
+}
+function getRepoName(root) {
+	return basename(root);
+}
+function getBranchName(root) {
+	try {
+		return git(root, [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		]).trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Does this branch still exist here? Answers **true** when git can't say: the
+* caller deletes the reviewer's threads on a false, so every ambiguous case has
+* to fall on the side of keeping them.
+*/
+function branchExists(root, branch) {
+	try {
+		git(root, [
+			"show-ref",
+			"--verify",
+			"--quiet",
+			`refs/heads/${branch}`
+		]);
+		return true;
+	} catch (err) {
+		return err.status !== 1;
+	}
+}
+/**
+* The name of the linked worktree we're in, or null in the main one. A linked
+* worktree's git dir is `<main>/.git/worktrees/<name>`, while the main worktree's
+* is a plain `.git`. Two worktrees of the same repo are otherwise
+* indistinguishable in the header.
+*/
+function getWorktreeName(root) {
+	try {
+		const gitDir = git(root, ["rev-parse", "--git-dir"]).trim();
+		const marker = `${sep}worktrees${sep}`;
+		if (!gitDir.includes(marker)) return null;
+		return basename(gitDir);
+	} catch {
+		return null;
+	}
+}
+function getHeadSha(root) {
+	try {
+		return git(root, ["rev-parse", "HEAD"]).trim();
+	} catch {
+		return null;
+	}
+}
+/**
+* Is `ancestor` in `descendant`'s history? Null when git couldn't answer (a sha
+* it no longer knows, a transient failure) — the callers lean opposite ways on
+* ambiguity (keep a landed marker, but never stamp one), so the ambiguity has
+* to survive the return.
+*/
+function isAncestor(root, ancestor, descendant) {
+	try {
+		git(root, [
+			"merge-base",
+			"--is-ancestor",
+			ancestor,
+			descendant
+		]);
+		return true;
+	} catch (err) {
+		return err.status === 1 ? false : null;
+	}
+}
+function getCommitSubject(root, sha) {
+	try {
+		return git(root, [
+			"log",
+			"-1",
+			"--format=%s",
+			sha
+		]).trim();
+	} catch {
+		return "";
+	}
+}
+function hasHead(root) {
+	try {
+		git(root, [
+			"rev-parse",
+			"--verify",
+			"HEAD"
+		]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+var MissingBaseError = class extends Error {
+	base;
+	constructor(base) {
+		super(`base branch '${base}' not found`);
+		this.base = base;
+	}
+};
+/**
+* The base a clean working tree most likely wants reviewing against: the
+* remote's default branch when origin/HEAD names one, else main/master.
+* Null when the repo offers no candidate, when HEAD *is* the candidate, or
+* when nothing was committed since forking from it — no hint is owed then.
+*/
+function suggestedBase(root) {
+	try {
+		const candidate = defaultBranch(root);
+		if (candidate === null) return null;
+		if (candidate === git(root, [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		]).trim()) return null;
+		const mergeBase = git(root, [
+			"merge-base",
+			candidate,
+			"HEAD"
+		]).trim();
+		const commits = Number.parseInt(git(root, [
+			"rev-list",
+			"--count",
+			`${mergeBase}..HEAD`
+		]).trim(), 10);
+		return Number.isInteger(commits) && commits > 0 ? {
+			base: candidate,
+			commits
+		} : null;
+	} catch {
+		return null;
+	}
+}
+function defaultBranch(root) {
+	const candidates = [];
+	try {
+		const ref = git(root, [
+			"rev-parse",
+			"--abbrev-ref",
+			"origin/HEAD"
+		]).trim();
+		const short = ref.replace(/^origin\//, "");
+		if (short) candidates.push(short, ref);
+	} catch {}
+	candidates.push("main", "master");
+	for (const name of candidates) try {
+		git(root, [
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			name
+		]);
+		return name;
+	} catch {}
+	return null;
+}
+function getRawDiff(root, spec) {
+	if (spec.kind === "working-tree") {
+		if (!hasHead(root)) return "";
+		return git(root, [
+			"diff",
+			...DIFF_FLAGS,
+			"HEAD"
+		]);
+	}
+	let mergeBase;
+	try {
+		mergeBase = git(root, [
+			"merge-base",
+			spec.base,
+			"HEAD"
+		]).trim();
+	} catch {
+		throw new MissingBaseError(spec.base);
+	}
+	return git(root, [
+		"diff",
+		...DIFF_FLAGS,
+		mergeBase
+	]);
+}
+function getStagedPaths(root) {
+	try {
+		const out = git(root, [
+			"diff",
+			"--name-only",
+			"--cached"
+		]).trim();
+		return new Set(out ? out.split("\n") : []);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+function getUntrackedPaths(root) {
+	const out = git(root, [
+		"ls-files",
+		"--others",
+		"--exclude-standard"
+	]).trim();
+	return out ? out.split("\n") : [];
+}
+function binaryStub(file) {
+	return [
+		`diff --git a/${file} b/${file}`,
+		"new file mode 100644",
+		"index 0000000..0000001",
+		`Binary files /dev/null and b/${file} differ`
+	].join("\n");
+}
+/** One scratch page for the sniff below. 8KB is past `Buffer.poolSize / 2`, so a
+* fresh `allocUnsafe` per file misses the shared pool and mallocs. The sniff is
+* synchronous and never re-entered, so reuse is safe. */
+const sniffBuffer = Buffer.allocUnsafe(SNIFF_BYTES);
+/**
+* Git's own test: a NUL byte in the first 8KB means binary. Read 8KB, not the
+* file — `readFileSync` pulled the whole thing in to look at its first page, so
+* an untracked 2GB core dump cost a 2GB allocation on every recompute.
+*/
+function looksBinary(absPath, size) {
+	if (size === 0) return false;
+	let fd = null;
+	try {
+		fd = openSync(absPath, "r");
+		const read = readSync(fd, sniffBuffer, 0, Math.min(size, SNIFF_BYTES), 0);
+		for (let i = 0; i < read; i++) if (sniffBuffer[i] === 0) return true;
+		return false;
+	} catch {
+		return true;
+	} finally {
+		if (fd !== null) closeSync(fd);
+	}
+}
+function getUntrackedDiff(root) {
+	return patchesForUntracked(root, getUntrackedPaths(root));
+}
+function patchesForUntracked(root, files) {
+	const patches = [];
+	for (const file of files) {
+		const absPath = join(root, file);
+		let stats;
+		try {
+			stats = lstatSync(absPath);
+		} catch {
+			continue;
+		}
+		if (stats.isSymbolicLink()) {
+			const target = readlinkSync(absPath, "utf-8");
+			patches.push([
+				`diff --git a/${file} b/${file}`,
+				"new file mode 120000",
+				"index 0000000..0000001",
+				"--- /dev/null",
+				`+++ b/${file}`,
+				"@@ -0,0 +1 @@",
+				`+${target}`,
+				"\"
+			].join("\n"));
+			continue;
+		}
+		if (!stats.isFile()) continue;
+		if (stats.size > MAX_INLINE_BYTES || looksBinary(absPath, stats.size)) {
+			patches.push(binaryStub(file));
+			continue;
+		}
+		let content;
+		try {
+			content = readFileSync(absPath, "utf-8");
+		} catch {
+			continue;
+		}
+		const trailingNewline = content.endsWith("\n");
+		const lines = trailingNewline ? content.slice(0, -1).split("\n") : content.split("\n");
+		if (content === "") {
+			patches.push([
+				`diff --git a/${file} b/${file}`,
+				"new file mode 100644",
+				"index 0000000..0000001"
+			].join("\n"));
+			continue;
+		}
+		const body = `+${lines.join("\n+")}`;
+		patches.push([
+			`diff --git a/${file} b/${file}`,
+			"new file mode 100644",
+			"index 0000000..0000001",
+			"--- /dev/null",
+			`+++ b/${file}`,
+			`@@ -0,0 +1,${lines.length} @@`,
+			trailingNewline ? body : `${body}\n\`
+		].join("\n"));
+	}
+	return patches.join("\n");
+}
+function getFullDiff(root, spec) {
+	return [getRawDiff(root, spec), getUntrackedDiff(root)].filter(Boolean).join("\n");
+}
+async function hasHeadAsync(root) {
+	try {
+		await gitAsync(root, [
+			"rev-parse",
+			"--verify",
+			"HEAD"
+		]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function getBranchNameAsync(root) {
+	try {
+		return (await gitAsync(root, [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		])).trim();
+	} catch {
+		return "";
+	}
+}
+async function getStagedPathsAsync(root) {
+	try {
+		const out = (await gitAsync(root, [
+			"diff",
+			"--name-only",
+			"--cached"
+		])).trim();
+		return new Set(out ? out.split("\n") : []);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+async function getRawDiffAsync(root, spec) {
+	if (spec.kind === "working-tree") {
+		if (!await hasHeadAsync(root)) return "";
+		return gitAsync(root, [
+			"diff",
+			...DIFF_FLAGS,
+			"HEAD"
+		]);
+	}
+	let mergeBase;
+	try {
+		mergeBase = (await gitAsync(root, [
+			"merge-base",
+			spec.base,
+			"HEAD"
+		])).trim();
+	} catch {
+		throw new MissingBaseError(spec.base);
+	}
+	return gitAsync(root, [
+		"diff",
+		...DIFF_FLAGS,
+		mergeBase
+	]);
+}
+/**
+* The untracked half. `ls-files` walks the worktree honouring gitignore — ~540ms
+* of the ~700ms on the repo that prompted this — so it goes async. The per-file
+* reads below it are bounded by `MAX_INLINE_BYTES` and stay synchronous.
+*/
+async function getUntrackedDiffAsync(root) {
+	const paths = (await gitAsync(root, [
+		"ls-files",
+		"--others",
+		"--exclude-standard"
+	])).trim();
+	return patchesForUntracked(root, paths ? paths.split("\n") : []);
+}
+async function getFullDiffAsync(root, spec) {
+	const [raw, untracked] = await Promise.all([getRawDiffAsync(root, spec), getUntrackedDiffAsync(root)]);
+	return [raw, untracked].filter(Boolean).join("\n");
+}
+function isSafeRepoPath(root, relPath) {
+	return resolve(root, relPath).startsWith(resolve(root) + sep);
+}
+function getHeadFileBytes(root, relPath) {
+	if (!isSafeRepoPath(root, relPath)) return null;
+	const full = resolve(root, relPath);
+	try {
+		const stats = lstatSync(full);
+		if (stats.isSymbolicLink()) return Buffer.from(readlinkSync(full, "utf-8"));
+		if (!stats.isFile()) return null;
+		const realRoot = realpathSync(resolve(root));
+		const real = realpathSync(full);
+		if (real !== realRoot && !real.startsWith(realRoot + sep)) return null;
+		return readFileSync(full);
+	} catch {
+		return null;
+	}
+}
+function getBaseFileBytes(root, ref, relPath) {
+	if (!isSafeRepoPath(root, relPath)) return null;
+	try {
+		return execFileSync("git", ["show", `${ref}:${relPath}`], {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			maxBuffer: MAX_BUFFER
+		});
+	} catch {
+		return null;
+	}
+}
+function resolveBaseRef(root, spec) {
+	if (spec.kind === "working-tree") return "HEAD";
+	try {
+		return git(root, [
+			"merge-base",
+			spec.base,
+			"HEAD"
+		]).trim();
+	} catch {
+		throw new MissingBaseError(spec.base);
+	}
+}
+//#endregion
+//#region src/server/db.ts
+const require = createRequire(import.meta.url);
+/** Signal 0 asks "does this process exist?" without touching it; EPERM is still
+* a yes (it exists, it just isn't ours). */
+function pidAlive$1(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+function defaultDbPath() {
+	return process.env.DIFFO_DB || join(homedir(), ".diffo", "diffo.db");
+}
+/** node:sqlite still emits an ExperimentalWarning on load — swallow exactly that
+* one so every CLI run isn't noisy. */
+function loadSqlite() {
+	const originalEmit = process.emitWarning.bind(process);
+	process.emitWarning = ((warning, ...rest) => {
+		if (String(warning instanceof Error ? warning.message : warning).includes("SQLite")) return;
+		return originalEmit(warning, ...rest);
+	});
+	try {
+		return require("node:sqlite");
+	} finally {
+		process.emitWarning = originalEmit;
+	}
+}
+/** A bump DROPS the affected table rather than migrating it (pre-release). */
+const SCHEMA_VERSION = 2;
+var DiffoDb = class {
+	db;
+	path;
+	constructor(path = defaultDbPath()) {
+		this.path = path;
+		mkdirSync(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		const { DatabaseSync } = loadSqlite();
+		this.db = new DatabaseSync(path);
+		chmodSync(path, 384);
+		this.db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 3000; PRAGMA journal_size_limit = 4194304;");
+		const { user_version: version } = this.db.prepare("PRAGMA user_version").get();
+		if (version <= SCHEMA_VERSION) {
+			const known = /* @__PURE__ */ new Set([
+				"reviews",
+				"servers",
+				"repo_ports"
+			]);
+			const tables = this.db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").all();
+			for (const { name } of tables) if (!known.has(name)) this.db.exec(`DROP TABLE IF EXISTS "${name.replaceAll("\"", "\"\"")}"`);
+		}
+		if (version < SCHEMA_VERSION) this.db.exec("DROP TABLE IF EXISTS reviews");
+		this.db.exec(`
+      CREATE TABLE IF NOT EXISTS reviews (
+        repo_path  TEXT NOT NULL,
+        branch     TEXT NOT NULL,
+        base       TEXT NOT NULL,
+        state_json TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (repo_path, branch, base)
+      );
+      CREATE TABLE IF NOT EXISTS servers (
+        repo_path  TEXT PRIMARY KEY,
+        port       INTEGER NOT NULL,
+        pid        INTEGER NOT NULL,
+        started_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS repo_ports (
+        repo_path TEXT PRIMARY KEY,
+        port      INTEGER NOT NULL
+      );
+      PRAGMA user_version = ${SCHEMA_VERSION};
+    `);
+		this.pruneVanishedRepos();
+	}
+	/**
+	* Rows about a worktree that is gone can never be reached again — the path *is*
+	* the key. An unmounted volume looks the same as a deleted worktree, so its rows
+	* go too; the `servers` row needs its process dead as well, or a live server's
+	* claim could be dropped over a moment of unreachability.
+	*/
+	pruneVanishedRepos() {
+		for (const { repo_path } of this.distinctRepoPaths("reviews")) if (!existsSync(repo_path)) this.db.prepare("DELETE FROM reviews WHERE repo_path = ?").run(repo_path);
+		for (const { repo_path } of this.distinctRepoPaths("repo_ports")) if (!existsSync(repo_path)) this.db.prepare("DELETE FROM repo_ports WHERE repo_path = ?").run(repo_path);
+		const servers = this.db.prepare("SELECT repo_path, pid FROM servers").all();
+		for (const { repo_path, pid } of servers) if (!existsSync(repo_path) && !pidAlive$1(pid)) this.db.prepare("DELETE FROM servers WHERE repo_path = ?").run(repo_path);
+		this.pruneStaleReviews();
+	}
+	/**
+	* Reviews the reviewer can never return to: a branch that no longer exists, or
+	* one untouched for `REVIEW_TTL_DAYS`. Branch existence is asked of git rather
+	* than assumed — if git can't answer the row is kept, because guessing here
+	* deletes threads.
+	*/
+	pruneStaleReviews() {
+		const cutoff = (/* @__PURE__ */ new Date(Date.now() - 5184e6)).toISOString();
+		const stale = this.db.prepare("DELETE FROM reviews WHERE updated_at < ?").run(cutoff);
+		if (Number(stale.changes) > 0) {
+			this.checkpoint();
+			return;
+		}
+		const rows = this.db.prepare("SELECT DISTINCT repo_path, branch FROM reviews").all();
+		for (const { repo_path, branch } of rows) {
+			if (branch === "" || branchExists(repo_path, branch)) continue;
+			this.db.prepare("DELETE FROM reviews WHERE repo_path = ? AND branch = ?").run(repo_path, branch);
+		}
+	}
+	/** Fold the write-ahead log back into the database file and truncate it. WAL
+	* only shrinks at a checkpoint, which a long-lived server never reaches. */
+	checkpoint() {
+		try {
+			this.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+		} catch {}
+	}
+	distinctRepoPaths(table) {
+		return this.db.prepare(`SELECT DISTINCT repo_path FROM ${table}`).all();
+	}
+	getReview(scope) {
+		return this.db.prepare("SELECT state_json FROM reviews WHERE repo_path = ? AND branch = ? AND base = ?").get(scope.repoPath, scope.branch, scope.base)?.state_json ?? null;
+	}
+	setReview(scope, stateJson) {
+		this.db.prepare(`INSERT INTO reviews (repo_path, branch, base, state_json, updated_at) VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(repo_path, branch, base) DO UPDATE SET state_json = excluded.state_json, updated_at = excluded.updated_at`).run(scope.repoPath, scope.branch, scope.base, stateJson, (/* @__PURE__ */ new Date()).toISOString());
+	}
+	/**
+	* Claim this repo for a starting server — atomically, so the row is a lock and
+	* not merely a note: two servers hold separate copies of the same review and
+	* `setReview` writes the whole blob, so one would erase the other's threads.
+	* `claimed` comes from the insert itself, the only answer two lookalike servers
+	* can't confuse.
+	*/
+	claimServer(repoPath, port, pid) {
+		const { changes } = this.db.prepare(`INSERT INTO servers (repo_path, port, pid, started_at) VALUES (?, ?, ?, ?)
+         ON CONFLICT(repo_path) DO NOTHING`).run(repoPath, port, pid, (/* @__PURE__ */ new Date()).toISOString());
+		return {
+			claimed: Number(changes) === 1,
+			holder: this.getServer(repoPath)
+		};
+	}
+	getPreferredPort(repoPath) {
+		return this.db.prepare("SELECT port FROM repo_ports WHERE repo_path = ?").get(repoPath)?.port ?? null;
+	}
+	setPreferredPort(repoPath, port) {
+		this.db.prepare(`INSERT INTO repo_ports (repo_path, port) VALUES (?, ?)
+         ON CONFLICT(repo_path) DO UPDATE SET port = excluded.port`).run(repoPath, port);
+	}
+	getServer(repoPath) {
+		const row = this.db.prepare("SELECT port, pid, started_at FROM servers WHERE repo_path = ?").get(repoPath);
+		return row ? {
+			repoPath,
+			port: row.port,
+			pid: row.pid,
+			startedAt: row.started_at
+		} : null;
+	}
+	/** Remove a registration — but only the one being asked about. A dying server
+	* passes its own port so it can't wipe the row of a newer server that already
+	* replaced it. */
+	removeServer(repoPath, port) {
+		if (port === void 0) this.db.prepare("DELETE FROM servers WHERE repo_path = ?").run(repoPath);
+		else this.db.prepare("DELETE FROM servers WHERE repo_path = ? AND port = ?").run(repoPath, port);
+	}
+	close() {
+		this.db.close();
+	}
+};
+//#endregion
+//#region src/version.ts
+/**
+* This build's version, read from our own package.json. The CLI and the server both
+* report it, and the CLI compares the two: a running server from another build gets
+* replaced, not reused.
+*
+* The walk-up exists because this module sits at a different depth in dev (src/) and
+* in the bundle (dist/); the name check keeps a stray package.json out of it.
+*/
+const VERSION = (() => {
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (let depth = 0; depth < 3; depth++) {
+		dir = resolve(dir, "..");
+		try {
+			const pkg = JSON.parse(readFileSync(resolve(dir, "package.json"), "utf-8"));
+			if (pkg.name === "diffo" && typeof pkg.version === "string") return pkg.version;
+		} catch {}
+	}
+	return "0.0.0";
+})();
+//#endregion
+//#region src/server/delivery.ts
+const STALL_AFTER_MS = 3e5;
+const REPLY_GRACE_MS = 9e4;
+/** A re-poll within this window of a delivery reads as "hasn't started yet". */
+const BATCH_SETTLE_MS = 2e3;
+/** Signal 0 probes existence without touching the process; EPERM still proves it exists. */
+function pidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+var DeliveryQueue = class DeliveryQueue {
+	stallAfterMs;
+	replyGraceMs;
+	liveness;
+	batchSettleMs;
+	buckets = /* @__PURE__ */ new Map();
+	scope = "";
+	waiter = null;
+	awaitingReply = false;
+	/** Thread id -> epoch ms it was delivered. */
+	deliveredAt = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	stalled = false;
+	stallTimer = null;
+	betweenPolls = false;
+	graceTimer = null;
+	lastDetach = null;
+	since = Date.now();
+	lastDetail = {
+		state: "waiting",
+		reason: "no-agent"
+	};
+	owner = null;
+	batch = null;
+	batchWatch = null;
+	waiterWatch = null;
+	batchListeners = /* @__PURE__ */ new Set();
+	constructor(stallAfterMs = STALL_AFTER_MS, replyGraceMs = REPLY_GRACE_MS, liveness = {}, batchSettleMs = BATCH_SETTLE_MS) {
+		this.stallAfterMs = stallAfterMs;
+		this.replyGraceMs = replyGraceMs;
+		this.liveness = liveness;
+		this.batchSettleMs = batchSettleMs;
+	}
+	onBatchClosed(listener) {
+		this.batchListeners.add(listener);
+		return () => this.batchListeners.delete(listener);
+	}
+	closeBatch(reason) {
+		const batch = this.batch;
+		if (!batch) return;
+		const closed = {
+			threadIds: batch.threadIds,
+			unanswered: [...this.deliveredAt.keys()],
+			deliveredAt: batch.deliveredAt,
+			closedAt: Date.now(),
+			reason
+		};
+		this.batch = null;
+		this.deliveredAt.clear();
+		this.awaitingReply = false;
+		this.stalled = false;
+		this.clearStall();
+		this.clearBatchWatch();
+		for (const listener of this.batchListeners) listener(closed);
+	}
+	armBatchWatch() {
+		this.clearBatchWatch();
+		const isAlive = this.liveness.isAlive ?? pidAlive;
+		const timer = setInterval(() => {
+			if (!this.batch) return this.clearBatchWatch();
+			const pid = this.owner;
+			if (pid === null || isAlive(pid)) return;
+			this.closeBatch("gone");
+			this.notify();
+		}, this.liveness.checkEveryMs ?? 5e3);
+		timer.unref?.();
+		this.batchWatch = timer;
+	}
+	clearBatchWatch() {
+		if (this.batchWatch !== null) clearInterval(this.batchWatch);
+		this.batchWatch = null;
+	}
+	static clean(pid) {
+		return pid !== null && Number.isInteger(pid) && pid > 1 ? pid : null;
+	}
+	ownerConnected() {
+		if (this.owner === null) return false;
+		if (this.waiter === null && this.batch === null) return false;
+		return (this.liveness.isAlive ?? pidAlive)(this.owner);
+	}
+	ownerPid() {
+		return this.ownerConnected() ? this.owner : null;
+	}
+	/**
+	* A poll attaches for its session; the newest poll always carries the review.
+	* Returns the pid of a still-live session it took the review from, so both
+	* sides can say a hand-off happened. Null when the review was free.
+	*/
+	claimSession(pid) {
+		const claimant = DeliveryQueue.clean(pid);
+		const previous = this.ownerConnected() ? this.owner : null;
+		this.owner = claimant;
+		return previous !== null && previous !== claimant ? previous : null;
+	}
+	/**
+	* A non-poll verb (a `reply`) named its session. It may adopt an unowned
+	* review, but never take one off the session that holds it.
+	*/
+	noteSession(pid) {
+		const caller = DeliveryQueue.clean(pid);
+		if (caller === null) return;
+		if (this.owner === null) this.owner = caller;
+	}
+	bucket() {
+		let bucket = this.buckets.get(this.scope);
+		if (!bucket) {
+			bucket = {
+				threads: /* @__PURE__ */ new Set(),
+				finish: null
+			};
+			this.buckets.set(this.scope, bucket);
+		}
+		return bucket;
+	}
+	rescope(scope) {
+		if (scope === this.scope) return;
+		this.scope = scope;
+		if (this.hasPending() && this.waiter !== null) this.wake();
+		else this.notify();
+	}
+	presence() {
+		if (this.awaitingReply) return "working";
+		if (this.waiter) return "listening";
+		if (this.betweenPolls) return "working";
+		return "waiting";
+	}
+	presenceDetail() {
+		return {
+			state: this.presence(),
+			reason: this.reason(),
+			since: this.since
+		};
+	}
+	reason() {
+		if (this.awaitingReply) return this.stalled ? "stalled" : "delivered";
+		if (this.waiter) return "polling";
+		if (this.betweenPolls) return "replied";
+		return this.lastDetach ?? "no-agent";
+	}
+	hasListener() {
+		return this.waiter !== null;
+	}
+	deliveredThreadIds() {
+		return [...this.deliveredAt.keys()];
+	}
+	currentBatch() {
+		if (!this.batch) return null;
+		const ids = new Set(this.batch.threadIds);
+		for (const id of this.deliveredAt.keys()) ids.add(id);
+		return {
+			threadIds: [...ids],
+			answered: [...ids].filter((id) => !this.deliveredAt.has(id))
+		};
+	}
+	queuedThreadIds() {
+		return [...this.buckets.get(this.scope)?.threads ?? []];
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	notify() {
+		const state = this.presence();
+		const reason = this.reason();
+		const prev = this.lastDetail;
+		if (prev.state !== state || prev.reason !== reason) {
+			this.since = Date.now();
+			this.lastDetail = {
+				state,
+				reason
+			};
+		}
+		for (const listener of this.listeners) listener(state);
+	}
+	armStall() {
+		this.clearStall();
+		const timer = setTimeout(() => {
+			this.stallTimer = null;
+			if (!this.awaitingReply || this.stalled) return;
+			this.stalled = true;
+			this.notify();
+		}, this.stallAfterMs);
+		timer.unref?.();
+		this.stallTimer = timer;
+	}
+	clearStall() {
+		if (this.stallTimer !== null) clearTimeout(this.stallTimer);
+		this.stallTimer = null;
+	}
+	armGrace() {
+		this.clearGrace();
+		this.betweenPolls = true;
+		const drop = () => {
+			this.graceTimer = null;
+			if (!this.betweenPolls) return;
+			this.betweenPolls = false;
+			this.notify();
+		};
+		const pid = this.owner;
+		if (pid === null) {
+			const timer = setTimeout(drop, this.replyGraceMs);
+			timer.unref?.();
+			this.graceTimer = timer;
+			return;
+		}
+		const isAlive = this.liveness.isAlive ?? pidAlive;
+		const capMs = this.liveness.capMs ?? 6e5;
+		const startedAt = Date.now();
+		const timer = setInterval(() => {
+			if (!this.betweenPolls) {
+				this.clearGrace();
+				return;
+			}
+			if (!isAlive(pid) || Date.now() - startedAt >= capMs) {
+				clearInterval(timer);
+				drop();
+			}
+		}, this.liveness.checkEveryMs ?? 5e3);
+		timer.unref?.();
+		this.graceTimer = timer;
+	}
+	clearGrace() {
+		if (this.graceTimer !== null) clearInterval(this.graceTimer);
+		this.graceTimer = null;
+		this.betweenPolls = false;
+	}
+	enqueueThreads(threadIds) {
+		const bucket = this.bucket();
+		for (const id of threadIds) bucket.threads.add(id);
+		const queued = this.waiter === null;
+		this.wake();
+		if (queued) this.notify();
+	}
+	enqueueFinish(coverage) {
+		this.bucket().finish = coverage;
+		this.wake();
+	}
+	drop(threadId) {
+		for (const bucket of this.buckets.values()) bucket.threads.delete(threadId);
+		this.deliveredAt.delete(threadId);
+		if (this.batch) this.batch.threadIds = this.batch.threadIds.filter((id) => id !== threadId);
+		this.notify();
+	}
+	/**
+	* Attach a poll. Resolves 'data' when there is feedback to take (possibly
+	* immediately), 'superseded' when a newer poll replaces this one, 'ended' on
+	* `diffo end`, or 'gone' when the agent's session dies while this poll waits.
+	*/
+	attach(onAbort) {
+		this.releaseWaiter("superseded");
+		this.clearGrace();
+		if (this.batch !== null) {
+			if (this.batch.sawReply || Date.now() - this.batch.deliveredAt >= this.batchSettleMs) this.closeBatch("repoll");
+		}
+		if (this.hasPending()) return Promise.resolve("data");
+		return new Promise((resolve) => {
+			const waiter = (outcome) => resolve(outcome);
+			this.waiter = waiter;
+			this.lastDetach = null;
+			this.armWaiterWatch();
+			this.notify();
+			onAbort?.(() => {
+				if (this.waiter === waiter) {
+					this.releaseWaiter(null);
+					this.lastDetach = "disconnected";
+					this.notify();
+				}
+			});
+		});
+	}
+	releaseWaiter(outcome) {
+		const waiter = this.waiter;
+		this.waiter = null;
+		this.clearWaiterWatch();
+		if (waiter && outcome !== null) waiter(outcome);
+	}
+	armWaiterWatch() {
+		this.clearWaiterWatch();
+		const isAlive = this.liveness.isAlive ?? pidAlive;
+		const timer = setInterval(() => {
+			if (this.waiter === null) return this.clearWaiterWatch();
+			const pid = this.owner;
+			if (pid === null || isAlive(pid)) return;
+			this.releaseWaiter("gone");
+			this.lastDetach = "disconnected";
+			this.notify();
+		}, this.liveness.checkEveryMs ?? 5e3);
+		timer.unref?.();
+		this.waiterWatch = timer;
+	}
+	clearWaiterWatch() {
+		if (this.waiterWatch !== null) clearInterval(this.waiterWatch);
+		this.waiterWatch = null;
+	}
+	hasPending() {
+		const bucket = this.buckets.get(this.scope);
+		return bucket !== void 0 && (bucket.threads.size > 0 || bucket.finish !== null);
+	}
+	wake() {
+		if (this.waiter === null) return;
+		this.releaseWaiter("data");
+	}
+	/**
+	* Peek at everything pending WITHOUT removing it. A pooled Finish wins: its
+	* prompt already carries every sent thread, so per-thread items are absorbed.
+	*/
+	take() {
+		const bucket = this.buckets.get(this.scope);
+		if (!bucket) return null;
+		if (bucket.finish !== null) return {
+			kind: "finish",
+			coverage: bucket.finish,
+			absorbedThreadIds: [...bucket.threads]
+		};
+		if (bucket.threads.size > 0) return {
+			kind: "threads",
+			threadIds: [...bucket.threads]
+		};
+		return null;
+	}
+	/** The poll response for this snapshot was fully written — NOW it counts as
+	* delivered. Clears exactly what the snapshot covered. */
+	confirm(snapshot, deliveredThreadIds) {
+		for (const bucket of this.buckets.values()) if (snapshot.kind === "finish") {
+			if (bucket.finish === snapshot.coverage) bucket.finish = null;
+			for (const id of snapshot.absorbedThreadIds) bucket.threads.delete(id);
+		} else for (const id of snapshot.threadIds) bucket.threads.delete(id);
+		const now = Date.now();
+		for (const id of deliveredThreadIds) this.deliveredAt.set(id, now);
+		this.awaitingReply = true;
+		this.batch = {
+			threadIds: [...deliveredThreadIds],
+			deliveredAt: now,
+			sawReply: false
+		};
+		this.armBatchWatch();
+		this.stalled = false;
+		this.armStall();
+		this.notify();
+	}
+	/** The agent replied on a thread. Returns how long since that thread's feedback
+	* was delivered, or null when the reply wasn't an answer to a delivery. */
+	agentReplied(threadId) {
+		const at = this.deliveredAt.get(threadId);
+		this.deliveredAt.delete(threadId);
+		if (this.batch) this.batch.sawReply = true;
+		if (this.deliveredAt.size > 0) {
+			if (this.awaitingReply) {
+				this.stalled = false;
+				this.armStall();
+				this.notify();
+			}
+		} else if (this.awaitingReply || this.stalled || this.betweenPolls) {
+			this.awaitingReply = false;
+			this.stalled = false;
+			this.clearStall();
+			this.armGrace();
+			this.notify();
+		}
+		return at === void 0 ? null : Date.now() - at;
+	}
+	end(sessionPid = null) {
+		const caller = DeliveryQueue.clean(sessionPid);
+		if (caller !== null && caller !== this.owner && this.ownerConnected()) return false;
+		this.owner = null;
+		this.releaseWaiter("ended");
+		this.closeBatch("ended");
+		this.awaitingReply = false;
+		this.stalled = false;
+		this.clearStall();
+		this.clearGrace();
+		this.deliveredAt.clear();
+		this.lastDetach = "ended";
+		this.notify();
+		return true;
+	}
+};
+//#endregion
+//#region src/server/idle.ts
+const IDLE_TIMEOUT_MS = 18e5;
+/** The idle budget for this process, or null when self-stop is off.
+* `DIFFO_IDLE_TIMEOUT_MS` overrides anywhere (0 or 'off' disables); otherwise only
+* a daemon (`DIFFO_DAEMON=1`, set by the spawning CLI) gets the default budget. */
+function resolveIdleTimeoutMs(env) {
+	const raw = env.DIFFO_IDLE_TIMEOUT_MS?.trim();
+	if (raw !== void 0 && raw !== "") {
+		if (raw === "off") return null;
+		const value = Number(raw);
+		if (!Number.isFinite(value) || value <= 0) return null;
+		return value;
+	}
+	return env.DIFFO_DAEMON === "1" ? IDLE_TIMEOUT_MS : null;
+}
+/**
+* Idleness is decided by live connections (browser tabs and agent polls) and
+* request recency — deliberately NOT by the delivery queue's state. Feedback the
+* agent never answered is durable (`rehydrateQueue` re-delivers it after a
+* respawn), so an abandoned batch must not hold the daemon alive forever.
+*/
+var IdleMonitor = class {
+	opts;
+	connections = 0;
+	lastActivity;
+	timer = null;
+	constructor(opts) {
+		this.opts = opts;
+		this.lastActivity = this.now();
+	}
+	now() {
+		return this.opts.now?.() ?? Date.now();
+	}
+	touch() {
+		this.lastActivity = this.now();
+	}
+	connect() {
+		this.connections++;
+		this.touch();
+	}
+	disconnect() {
+		this.connections = Math.max(0, this.connections - 1);
+		this.touch();
+	}
+	isIdle() {
+		if (this.connections > 0) return false;
+		return this.now() - this.lastActivity >= this.opts.timeoutMs;
+	}
+	start() {
+		if (this.timer) return;
+		const every = this.opts.checkEveryMs ?? 6e4;
+		const timer = setInterval(() => {
+			if (this.isIdle()) {
+				this.stop();
+				this.opts.onIdle();
+			}
+		}, every);
+		timer.unref?.();
+		this.timer = timer;
+	}
+	stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = null;
+	}
+};
+//#endregion
+//#region src/server/landed.ts
+/**
+* Keep the review's landed marker true to the repo. Called on every changeset
+* recompute (and once at startup, which is what catches a commit made while no
+* server ran):
+*
+* - The diff emptied while HEAD advanced past `seenHead` → the changeset was
+*   committed. Stamp `landed` — the UI's cue to offer a fresh start. A stash
+*   empties the diff without moving HEAD, so it never stamps; a branch switch
+*   is rescoped to its own review before this runs.
+* - A landed commit that left HEAD's history (reset, or an amend rewriting it)
+*   drops the marker — and an amend re-stamps in the same pass, because
+*   `seenHead` is still the pre-landing base and IS an ancestor of the
+*   rewritten commit.
+* - Everything here is metadata. Threads are never touched: only the reviewer
+*   clears a review, this just tells them when they can.
+*
+* `seenHead` advances only while the diff has files (tracking the base the
+* outstanding work sits on) or the review is empty (nothing to land). While an
+* empty diff hangs over a non-empty review it stays frozen at the base — the
+* fixed point that makes "amended" and "reset back" distinguishable above.
+*/
+function maintainLanded(review, hasFiles, git) {
+	const head = git.head();
+	if (head === null) return null;
+	const state = review.get();
+	const reviewEmpty = state.threads.length === 0 && !state.lastFinish;
+	let outcome = null;
+	if (state.landed && state.landed.sha !== head) {
+		if (git.isAncestor(state.landed.sha, head) === false) {
+			review.clearLanded();
+			outcome = "cleared";
+		}
+	}
+	if (!review.get().landed && !hasFiles && !reviewEmpty && state.seenHead !== void 0 && state.seenHead !== head && git.isAncestor(state.seenHead, head) === true) {
+		review.markLanded({
+			sha: head,
+			subject: git.subject(head),
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		outcome = "stamped";
+	}
+	if (hasFiles || reviewEmpty) review.noteHead(head);
+	return outcome;
+}
+//#endregion
+//#region src/server/review.ts
+const STATES = [
+	"open",
+	"sent",
+	"addressed",
+	"resolved"
+];
+var ReviewStore = class {
+	db;
+	state;
+	listeners = /* @__PURE__ */ new Set();
+	repoPath;
+	key;
+	constructor(root, db, spec) {
+		this.db = db;
+		this.repoPath = resolve(root);
+		this.key = {
+			repoPath: this.repoPath,
+			branch: getBranchName(this.repoPath),
+			base: spec.kind === "branch" ? spec.base : ""
+		};
+		this.state = this.load();
+	}
+	get scope() {
+		return this.key;
+	}
+	/**
+	* HEAD moved under a running server: swap to that branch's review. Deliberately
+	* does NOT commit first — the state on screen belongs to the branch we are
+	* leaving, and writing it under the new key is the bleed this scoping prevents.
+	*/
+	rescope(branch) {
+		if (branch === this.key.branch) return;
+		this.key = {
+			...this.key,
+			branch
+		};
+		this.state = this.load();
+		for (const listener of this.listeners) listener(this.state);
+	}
+	load() {
+		const stored = this.db.getReview(this.key);
+		return (stored !== null ? parseReview(stored) : null) ?? structuredClone(EMPTY_REVIEW);
+	}
+	get() {
+		return this.state;
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	createThread(anchor, text, codeContext, intent, author = "reviewer") {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return this.insert({
+			id: randomUUID(),
+			anchor,
+			state: "open",
+			...intent ? { intent } : {},
+			codeContext,
+			codeChanged: false,
+			messages: [{
+				id: randomUUID(),
+				author,
+				text,
+				at: now
+			}],
+			createdAt: now,
+			updatedAt: now
+		});
+	}
+	/**
+	* The closing note of a Finish round, as a thread. Anchored to the changeset
+	* and opened in the reviewer's voice, so it travels the ordinary path: the
+	* agent replies to it with `diffo reply`, the queue counts it as feedback
+	* still owed an answer, and the reviewer sees their own summing-up in the rail
+	* beside everything else they said.
+	*/
+	closingNote(text) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return this.insert({
+			id: randomUUID(),
+			anchor: { kind: "changeset" },
+			state: "open",
+			closingNote: true,
+			codeContext: null,
+			codeChanged: false,
+			messages: [{
+				id: randomUUID(),
+				author: "reviewer",
+				text,
+				at: now
+			}],
+			createdAt: now,
+			updatedAt: now
+		});
+	}
+	insert(thread) {
+		this.state = {
+			...this.state,
+			threads: [...this.state.threads, thread]
+		};
+		this.commit();
+		return thread;
+	}
+	/** `withheld` marks a reviewer reply the agent has not been given. Only ever true
+	* for the reviewer: an agent message proves the agent has the thread.
+	*
+	* `seenThroughMs` is when the delivery this agent reply answers was handed over.
+	* The reply is inserted after the messages that delivery carried and before any
+	* the reviewer raced in since — appended at the end, it would render as an
+	* answer to a comment it never saw, and the raced comment would stop reading
+	* as "waiting on the agent" even though it still is. */
+	addMessage(threadId, author, text, withheld = false, seenThroughMs) {
+		return this.update(threadId, ({ unanswered: _answered, ...thread }) => {
+			const message = {
+				id: randomUUID(),
+				author,
+				text,
+				at: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			const raced = author === "agent" && seenThroughMs !== void 0 ? thread.messages.findIndex((m) => Date.parse(m.at) > seenThroughMs) : -1;
+			return {
+				...thread,
+				...withheld && author === "reviewer" ? { withheld: true } : {},
+				messages: raced === -1 ? [...thread.messages, message] : [
+					...thread.messages.slice(0, raced),
+					message,
+					...thread.messages.slice(raced)
+				]
+			};
+		});
+	}
+	/** A delivery just handed these threads to the agent — remember through when,
+	* so replies and the typing indicator can tell delivered words from raced ones. */
+	markDelivered(threadIds) {
+		const ids = new Set(threadIds);
+		if (ids.size === 0) return;
+		const at = (/* @__PURE__ */ new Date()).toISOString();
+		this.state = {
+			...this.state,
+			threads: this.state.threads.map((t) => ids.has(t.id) ? {
+				...t,
+				deliveredThrough: at
+			} : t)
+		};
+		this.commit();
+	}
+	clearWithheld(threadIds) {
+		const ids = new Set(threadIds);
+		if (!this.state.threads.some((t) => ids.has(t.id) && t.withheld)) return;
+		this.state = {
+			...this.state,
+			threads: this.state.threads.map(({ withheld, ...t }) => ids.has(t.id) ? t : {
+				...t,
+				...withheld ? { withheld } : {}
+			})
+		};
+		this.commit();
+	}
+	markUnanswered(threadIds) {
+		this.setUnanswered(threadIds, (t) => !t.unanswered && t.state !== "resolved");
+	}
+	clearUnanswered(threadIds) {
+		this.setUnanswered(threadIds, (t) => t.unanswered === true);
+	}
+	setUnanswered(threadIds, applies) {
+		const wanted = new Set(threadIds);
+		let changed = false;
+		const threads = this.state.threads.map((thread) => {
+			if (!wanted.has(thread.id) || !applies(thread)) return thread;
+			changed = true;
+			const { unanswered: _was, ...rest } = thread;
+			return thread.unanswered ? rest : {
+				...rest,
+				unanswered: true
+			};
+		});
+		if (!changed) return;
+		this.state = {
+			...this.state,
+			threads
+		};
+		this.commit();
+	}
+	setState(threadId, state) {
+		return this.update(threadId, (thread) => ({
+			...thread,
+			state,
+			...state === "sent" && !thread.sentAt ? { sentAt: (/* @__PURE__ */ new Date()).toISOString() } : {},
+			...state === "resolved" ? { codeContext: null } : {}
+		}));
+	}
+	removeThread(threadId) {
+		const threads = this.state.threads.filter((t) => t.id !== threadId);
+		if (threads.length === this.state.threads.length) return false;
+		this.state = {
+			...this.state,
+			threads
+		};
+		this.commit();
+		return true;
+	}
+	/**
+	* Start the review over: threads, the last-finish record, and the landed
+	* marker all go. Not just the threads — a kept `lastFinish` would carry hunk
+	* ids from the dead changeset into the next review's "since last review"
+	* lens, reporting everything as new. `seenHead` survives: it describes the
+	* repo, not the review being discarded.
+	*/
+	reset() {
+		const ids = this.state.threads.map((t) => t.id);
+		if (ids.length === 0 && !this.state.lastFinish && !this.state.landed) return [];
+		const { lastFinish: _finish, landed: _landed, ...rest } = this.state;
+		this.state = {
+			...rest,
+			threads: []
+		};
+		this.commit();
+		return ids;
+	}
+	/** The base the work under review sits on — see `ReviewState.seenHead` for
+	* when the caller must NOT move it. */
+	noteHead(sha) {
+		if (this.state.seenHead === sha) return;
+		this.state = {
+			...this.state,
+			seenHead: sha
+		};
+		this.commit();
+	}
+	markLanded(landed) {
+		if (this.state.landed?.sha === landed.sha) return;
+		this.state = {
+			...this.state,
+			landed
+		};
+		this.commit();
+	}
+	clearLanded() {
+		if (!this.state.landed) return;
+		const { landed: _landed, ...rest } = this.state;
+		this.state = rest;
+		this.commit();
+	}
+	annotateAgentReplies(threadIds, durationMs) {
+		let changed = false;
+		const threads = this.state.threads.map((thread) => {
+			if (!threadIds.includes(thread.id)) return thread;
+			const index = thread.messages.findLastIndex((m) => m.author === "agent");
+			if (index === -1 || thread.messages[index].durationMs !== void 0) return thread;
+			changed = true;
+			const messages = [...thread.messages];
+			messages[index] = {
+				...messages[index],
+				durationMs
+			};
+			return {
+				...thread,
+				messages
+			};
+		});
+		if (!changed) return;
+		this.state = {
+			...this.state,
+			threads
+		};
+		this.commit();
+	}
+	send(threadId) {
+		const thread = this.state.threads.find((t) => t.id === threadId);
+		if (!thread) return null;
+		if (thread.state !== "open") return thread;
+		return this.setState(threadId, "sent");
+	}
+	finish(only) {
+		const flush = (t) => t.state === "open" && (only?.has(t.id) ?? true);
+		if (this.state.threads.some(flush)) {
+			this.state = {
+				...this.state,
+				threads: this.state.threads.map((t) => flush(t) ? {
+					...t,
+					state: "sent",
+					...t.sentAt ? {} : { sentAt: (/* @__PURE__ */ new Date()).toISOString() },
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				} : t)
+			};
+			this.commit();
+		}
+		return this.state.threads;
+	}
+	recordFinish(hunkIds, coverage) {
+		const lastFinish = {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			hunkIds: [...hunkIds],
+			coverage
+		};
+		this.state = {
+			...this.state,
+			lastFinish
+		};
+		this.commit();
+		return lastFinish;
+	}
+	markFinishCollected() {
+		const lastFinish = this.state.lastFinish;
+		if (!lastFinish || lastFinish.collectedAt) return;
+		this.state = {
+			...this.state,
+			lastFinish: {
+				...lastFinish,
+				collectedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		this.commit();
+	}
+	/**
+	* Changeset changed — reconcile hunk-anchored threads against the new hunk ids.
+	* Content-addressing does the work: an edited hunk has a new id, so its old one
+	* vanishes. `sent` + vanished → `addressed`; `open` + vanished → `codeChanged`,
+	* cleared again if it comes back (a revert).
+	*/
+	reconcile(currentHunkIds) {
+		let changed = false;
+		const threads = this.state.threads.map((thread) => {
+			if (thread.anchor.kind !== "hunk") return thread;
+			const exists = currentHunkIds.has(thread.anchor.hunkId);
+			if (thread.state === "sent" && !exists) {
+				changed = true;
+				return {
+					...thread,
+					state: "addressed",
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+			}
+			if ((thread.state === "open" || thread.state === "sent") && thread.codeChanged === exists) {
+				changed = true;
+				return {
+					...thread,
+					codeChanged: !exists
+				};
+			}
+			return thread;
+		});
+		if (!changed) return;
+		this.state = {
+			...this.state,
+			threads
+		};
+		this.commit();
+	}
+	update(threadId, change) {
+		const index = this.state.threads.findIndex((t) => t.id === threadId);
+		if (index === -1) return null;
+		const updated = {
+			...change(this.state.threads[index]),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const threads = [...this.state.threads];
+		threads[index] = updated;
+		this.state = {
+			...this.state,
+			threads
+		};
+		this.commit();
+		return updated;
+	}
+	commit() {
+		this.db.setReview(this.key, JSON.stringify(this.state));
+		for (const listener of this.listeners) listener(this.state);
+	}
+};
+/** Tolerant parse: agents hand-edit this file, so anything recoverable is
+* recovered. Threads with a broken shape are dropped, optional fields are filled
+* in. Returns null only when the file as a whole is unusable. */
+function parseReview(raw) {
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (typeof data !== "object" || data === null) return null;
+	const parsed = data;
+	const threads = parsed.threads;
+	if (!Array.isArray(threads)) return null;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const valid = threads.map((t) => normalizeThread(t, now)).filter((t) => t !== null);
+	const migrated = Array.isArray(parsed.suggestions) ? parsed.suggestions.map((s) => migrateLegacySuggestion(s, now)).filter((t) => t !== null) : [];
+	const lastFinish = normalizeLastFinish(parsed.lastFinish, now);
+	const landed = normalizeLanded(parsed.landed, now);
+	return {
+		version: 1,
+		threads: [...valid, ...migrated],
+		...lastFinish ? { lastFinish } : {},
+		...typeof parsed.seenHead === "string" && parsed.seenHead !== "" ? { seenHead: parsed.seenHead } : {},
+		...landed ? { landed } : {}
+	};
+}
+/** A landed marker without a sha can't be checked against history, so it is
+* dropped; the subject is only a caption and defaults away. */
+function normalizeLanded(value, now) {
+	if (typeof value !== "object" || value === null) return null;
+	const l = value;
+	if (typeof l.sha !== "string" || l.sha === "") return null;
+	return {
+		sha: l.sha,
+		subject: typeof l.subject === "string" ? l.subject : "",
+		at: typeof l.at === "string" ? l.at : now
+	};
+}
+/** A finish with no hunk ids can't answer the only question it exists for, so it is
+* dropped rather than kept as a record reporting "nothing changed". */
+function normalizeLastFinish(value, now) {
+	if (typeof value !== "object" || value === null) return null;
+	const f = value;
+	if (!Array.isArray(f.hunkIds)) return null;
+	return {
+		at: typeof f.at === "string" ? f.at : now,
+		hunkIds: f.hunkIds.filter((x) => typeof x === "string"),
+		coverage: normalizeCoverage(f.coverage),
+		...typeof f.collectedAt === "string" ? { collectedAt: f.collectedAt } : {}
+	};
+}
+function normalizeCoverage(value) {
+	const c = typeof value === "object" && value !== null ? value : {};
+	const count = (v) => typeof v === "number" && v >= 0 ? v : 0;
+	const fileList = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : void 0;
+	const changedFiles = fileList(c.changedFiles);
+	const commentedUnread = fileList(c.commentedUnread);
+	return {
+		viewedHunks: count(c.viewedHunks),
+		totalHunks: count(c.totalHunks),
+		...typeof c.viewedFiles === "number" ? { viewedFiles: count(c.viewedFiles) } : {},
+		...typeof c.totalFiles === "number" ? { totalFiles: count(c.totalFiles) } : {},
+		skippedFiles: fileList(c.skippedFiles) ?? [],
+		...changedFiles !== void 0 ? { changedFiles } : {},
+		...commentedUnread !== void 0 ? { commentedUnread } : {},
+		...REVIEW_VERDICTS.includes(c.verdict) ? { verdict: c.verdict } : {},
+		...typeof c.note === "string" ? { note: c.note } : {}
+	};
+}
+function migrateLegacySuggestion(value, now) {
+	if (typeof value !== "object" || value === null) return null;
+	const s = value;
+	if (typeof s.file !== "string" || typeof s.text !== "string") return null;
+	const at = typeof s.at === "string" ? s.at : now;
+	return {
+		id: typeof s.id === "string" ? s.id : randomUUID(),
+		anchor: {
+			kind: "file",
+			path: s.file
+		},
+		state: "open",
+		codeContext: null,
+		codeChanged: false,
+		messages: [{
+			id: randomUUID(),
+			author: "agent",
+			text: s.text,
+			at
+		}],
+		createdAt: at,
+		updatedAt: at
+	};
+}
+function parseAnchor(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const anchor = value;
+	if (anchor.kind === "hunk") {
+		if (typeof anchor.hunkId !== "string" || typeof anchor.path !== "string") return null;
+		if (anchor.side !== "old" && anchor.side !== "new") return null;
+		if (typeof anchor.line !== "number") return null;
+		return {
+			kind: "hunk",
+			hunkId: anchor.hunkId,
+			path: anchor.path,
+			side: anchor.side,
+			line: anchor.line
+		};
+	}
+	if (anchor.kind === "file") return typeof anchor.path === "string" ? {
+		kind: "file",
+		path: anchor.path
+	} : null;
+	return anchor.kind === "changeset" ? { kind: "changeset" } : null;
+}
+function normalizeThread(value, now) {
+	if (typeof value !== "object" || value === null) return null;
+	const t = value;
+	if (typeof t.id !== "string" || !STATES.includes(t.state)) return null;
+	const anchor = parseAnchor(t.anchor);
+	if (!anchor) return null;
+	if (!Array.isArray(t.messages)) return null;
+	const messages = [];
+	for (const m of t.messages) {
+		if (typeof m !== "object" || m === null) return null;
+		const msg = m;
+		if (typeof msg.text !== "string") return null;
+		if (msg.author !== "reviewer" && msg.author !== "agent") return null;
+		messages.push({
+			id: typeof msg.id === "string" ? msg.id : randomUUID(),
+			author: msg.author,
+			text: msg.text,
+			at: typeof msg.at === "string" ? msg.at : now,
+			...typeof msg.durationMs === "number" ? { durationMs: msg.durationMs } : {}
+		});
+	}
+	return {
+		id: t.id,
+		anchor,
+		state: t.state,
+		...THREAD_INTENTS.includes(t.intent) ? { intent: t.intent } : {},
+		codeContext: typeof t.codeContext === "string" ? t.codeContext : null,
+		codeChanged: t.codeChanged === true,
+		...t.unanswered === true ? { unanswered: true } : {},
+		...t.closingNote === true ? { closingNote: true } : {},
+		...typeof t.sentAt === "string" ? { sentAt: t.sentAt } : {},
+		messages,
+		createdAt: typeof t.createdAt === "string" ? t.createdAt : now,
+		updatedAt: typeof t.updatedAt === "string" ? t.updatedAt : now
+	};
+}
+//#endregion
+//#region src/server/parse.ts
+const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".bmp",
+	".svg",
+	".ico",
+	".avif"
+]);
+function isImagePath(path) {
+	const dot = path.lastIndexOf(".");
+	return dot !== -1 && IMAGE_EXTENSIONS.has(path.slice(dot).toLowerCase());
+}
+/** Content-addressed hunk identity: the hash covers the file path and the changed
+* lines only — not line numbers, not context. Editing the hunk itself mints a new
+* id; the occurrence index separates identical hunks within one file. */
+function hunkId(path, lines, occurrence) {
+	const changed = lines.filter((l) => l.kind !== "context").map((l) => `${l.kind === "add" ? "+" : "-"}${l.text}`).join("\n");
+	return createHash("sha256").update(`${path}\0${changed}\0${occurrence}`).digest("hex").slice(0, 16);
+}
+function parseSectionMeta(section) {
+	return {
+		renamedFrom: section.match(/^rename from (.+)$/m)?.[1] ?? null,
+		renamedTo: section.match(/^rename to (.+)$/m)?.[1] ?? null,
+		binary: /^Binary files .* differ$/m.test(section) || /^GIT binary patch$/m.test(section),
+		symlink: /^(?:new file|deleted file|new|old) mode 120000$/m.test(section) || /^index [0-9a-f.]+ 120000$/m.test(section)
+	};
+}
+function splitSections(patch) {
+	if (!patch.trim()) return [];
+	const sections = [];
+	const lines = patch.split("\n");
+	let current = null;
+	for (const line of lines) if (line.startsWith("diff --git ")) {
+		if (current) sections.push(current.join("\n"));
+		current = [line];
+	} else if (current) current.push(line);
+	if (current) sections.push(current.join("\n"));
+	return sections;
+}
+/**
+* `@@ -oldStart,oldCount +newStart,newCount @@ scope`. Both counts are optional in
+* the format and mean 1 when absent (`@@ -1 +1 @@`). The trailing scope is git's own
+* guess at what you are inside.
+*/
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
+/**
+* Read one hunk body, starting at the line after its header. The declared counts
+* are authoritative: consume exactly that many old and new lines and stop, rather
+* than reading up to the next `@@` — git's own rule, and what keeps the blank line
+* every patch ends with out of the last hunk.
+*/
+function parseHunkBody(lines, start, oldStart, newStart, oldCount, newCount) {
+	const out = [];
+	let oldNo = oldStart;
+	let newNo = newStart;
+	let remainingOld = oldCount;
+	let remainingNew = newCount;
+	let i = start;
+	while (remainingOld > 0 || remainingNew > 0) {
+		const line = lines[i];
+		if (line === void 0) break;
+		if (line.startsWith("@@") || line.startsWith("diff --git ")) break;
+		i++;
+		if (line.startsWith("\\")) continue;
+		if (line.startsWith("+")) {
+			out.push({
+				kind: "add",
+				oldNo: null,
+				newNo: newNo++,
+				text: line.slice(1)
+			});
+			remainingNew--;
+		} else if (line.startsWith("-")) {
+			out.push({
+				kind: "del",
+				oldNo: oldNo++,
+				newNo: null,
+				text: line.slice(1)
+			});
+			remainingOld--;
+		} else {
+			out.push({
+				kind: "context",
+				oldNo: oldNo++,
+				newNo: newNo++,
+				text: line.slice(1)
+			});
+			remainingOld--;
+			remainingNew--;
+		}
+	}
+	return {
+		lines: out,
+		next: i
+	};
+}
+function parseHunks(lines) {
+	const hunks = [];
+	let i = 0;
+	while (i < lines.length) {
+		const header = lines[i]?.match(HUNK_HEADER);
+		if (!header) {
+			i++;
+			continue;
+		}
+		const oldStart = Number(header[1]);
+		const newStart = Number(header[3]);
+		const body = parseHunkBody(lines, i + 1, oldStart, newStart, header[2] === void 0 ? 1 : Number(header[2]), header[4] === void 0 ? 1 : Number(header[4]));
+		const context = (header[5] ?? "").trim();
+		hunks.push({
+			oldStart,
+			newStart,
+			context: context === "" ? null : context,
+			lines: body.lines
+		});
+		i = body.next;
+	}
+	return hunks;
+}
+/**
+* `--- a/x` / `+++ b/x`, read only from the part of the section before the first
+* `@@`. That bound is load-bearing: inside a hunk body an added line starting with
+* `++` is spelled `+++ …`, so scanning the whole section would read file content as
+* a path header.
+*/
+function parseSectionPaths(section, lines) {
+	let from = null;
+	let to = null;
+	for (const line of lines) {
+		if (line.startsWith("@@")) break;
+		if (from === null && line.startsWith("--- ")) from = diffPath(line.slice(4));
+		else if (to === null && line.startsWith("+++ ")) to = diffPath(line.slice(4));
+	}
+	return {
+		from,
+		to,
+		isNew: from === "/dev/null" || /^new file mode /m.test(section),
+		isDeleted: to === "/dev/null" || /^deleted file mode /m.test(section)
+	};
+}
+function diffPath(raw) {
+	const path = raw.split("	", 1)[0] ?? raw;
+	return path === "/dev/null" ? path : stripAB(path);
+}
+function parsePatch(patch) {
+	const files = [];
+	for (const section of splitSections(patch)) {
+		const sectionLines = section.split("\n");
+		const meta = parseSectionMeta(section);
+		const paths = parseSectionPaths(section, sectionLines);
+		let path;
+		let oldPath = null;
+		let status;
+		if (meta.renamedTo) {
+			path = meta.renamedTo;
+			oldPath = meta.renamedFrom;
+			status = "renamed";
+		} else if (paths.isNew) {
+			path = paths.to ?? headerPath(section);
+			status = "added";
+		} else if (paths.isDeleted) {
+			path = paths.from ?? headerPath(section);
+			status = "deleted";
+		} else if (paths.to !== null && paths.to !== "/dev/null") {
+			path = paths.to;
+			status = "modified";
+		} else {
+			path = headerPath(section);
+			status = "modified";
+		}
+		const kind = meta.symlink ? "symlink" : meta.binary ? isImagePath(path) ? "image" : "binary" : isImagePath(path) ? "image" : "text";
+		const seen = /* @__PURE__ */ new Map();
+		const hunks = meta.binary ? [] : parseHunks(sectionLines).map((hunk) => {
+			const lines = hunk.lines;
+			const contentKey = lines.filter((l) => l.kind !== "context").map((l) => `${l.kind}:${l.text}`).join("\n");
+			const occurrence = seen.get(contentKey) ?? 0;
+			seen.set(contentKey, occurrence + 1);
+			return {
+				id: hunkId(path, lines, occurrence),
+				path,
+				oldStart: hunk.oldStart,
+				newStart: hunk.newStart,
+				lines,
+				...hunk.context === null ? {} : { context: hunk.context }
+			};
+		});
+		files.push({
+			path,
+			oldPath,
+			status,
+			kind,
+			staged: false,
+			hunks
+		});
+	}
+	return files;
+}
+function stripAB(p) {
+	return p.startsWith("b/") || p.startsWith("a/") ? p.slice(2) : p;
+}
+function headerPath(section) {
+	const header = section.split("\n", 1)[0] ?? "";
+	return header.match(/^diff --git a\/(.*) b\/(.*)$/)?.[2] ?? header.replace(/^diff --git /, "");
+}
+//#endregion
+//#region src/server/changeset.ts
+function stats$1(files) {
+	let additions = 0;
+	let deletions = 0;
+	for (const file of files) for (const hunk of file.hunks) for (const line of hunk.lines) if (line.kind === "add") additions++;
+	else if (line.kind === "del") deletions++;
+	return {
+		files: files.length,
+		additions,
+		deletions
+	};
+}
+/** Head-side line count — what sizes the expandable gap after a file's last hunk. */
+function headLineCount(root, file) {
+	if (file.kind !== "text" || file.status === "deleted") return null;
+	const bytes = getHeadFileBytes(root, file.path);
+	if (bytes === null) return null;
+	const text = bytes.toString("utf-8");
+	if (text === "") return 0;
+	return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+}
+function buildChangesetFromRaw(root, spec, rawDiff, version) {
+	const staged = getStagedPaths(root);
+	const files = parsePatch(rawDiff).map((file) => ({
+		...file,
+		staged: staged.has(file.path) || file.oldPath !== null && staged.has(file.oldPath),
+		newLineCount: headLineCount(root, file)
+	}));
+	return {
+		version,
+		spec,
+		repo: {
+			path: resolve(root),
+			name: getRepoName(root),
+			branch: getBranchName(root),
+			worktree: getWorktreeName(root)
+		},
+		files,
+		stats: stats$1(files)
+	};
+}
+//#endregion
+//#region src/server/store.ts
+var ChangesetStore = class {
+	root;
+	spec;
+	version = 0;
+	hash = null;
+	changeset;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(root, spec) {
+		this.root = root;
+		this.spec = spec;
+		this.refreshSync();
+	}
+	async refresh() {
+		this.inFlight ??= this.compute().finally(() => {
+			this.inFlight = null;
+		});
+		return this.inFlight;
+	}
+	inFlight = null;
+	async compute() {
+		const [raw, staged, branch] = await Promise.all([
+			getFullDiffAsync(this.root, this.spec),
+			getStagedPathsAsync(this.root),
+			getBranchNameAsync(this.root)
+		]);
+		return this.apply(raw, staged, branch);
+	}
+	refreshSync() {
+		return this.apply(getFullDiff(this.root, this.spec), getStagedPaths(this.root), getBranchName(this.root));
+	}
+	apply(raw, staged, branch) {
+		const stagedKey = [...staged].sort().join("\n");
+		const newHash = createHash("sha256").update(raw).update("\0").update(stagedKey).update("\0").update(branch).digest("hex");
+		if (newHash === this.hash) return false;
+		this.hash = newHash;
+		this.version++;
+		this.changeset = buildChangesetFromRaw(this.root, this.spec, raw, this.version);
+		for (const listener of this.listeners) listener(this.changeset);
+		return true;
+	}
+	get() {
+		return this.changeset;
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+};
+//#endregion
+//#region src/server/watcher.ts
+const DEBOUNCE_MS = 300;
+const MAX_COOLDOWN_MS = 5e3;
+const GIT_STATE_FILES = /* @__PURE__ */ new Set([
+	"HEAD",
+	"index",
+	"packed-refs",
+	"logs/HEAD"
+]);
+/**
+* Which relative paths can change the diff. Watching the `.git` directory rather
+* than those four files is deliberate: git replaces HEAD and index by lockfile
+* rename, so a watch pinned to the file follows the old inode and goes deaf.
+*
+* Everything else passes, gitignored build output included — the cooldown below
+* bounds what a build storm costs, and the store's hash dedup keeps it correct.
+*/
+function affectsDiff(rel) {
+	const parts = rel.split(/[\\/]/);
+	if (parts.includes("node_modules")) return false;
+	if (parts[0] !== ".git") return true;
+	return GIT_STATE_FILES.has(parts.slice(1).join("/"));
+}
+/**
+* Watch the repo for anything that can change the diff — working-tree writes, plus
+* the git state files behind commits, branch switches and staging. Events are
+* debounced into one `onChange` per burst.
+*
+* **One** watcher for the whole tree, via the platform's recursive watch: a
+* per-directory walk over a 17,639-directory monorepo opened ~16.5k descriptors and
+* hit `EMFILE`, leaving the server bound to its port and unable to accept a
+* connection. Recursive watch costs one descriptor however big the repo is.
+*/
+function watchRepo(root, onChange, debounceMs = DEBOUNCE_MS) {
+	let timer = null;
+	/**
+	* How long the last recompute took — the cooldown before the next one. A full
+	* recompute measures ~700ms on a large repo and runs on the event loop, so a
+	* debounce alone does not bound it: a build writing continuously buys another
+	* stall per surviving burst. Charging the measured cost back as idle time caps the
+	* duty cycle near 50%. Nothing is dropped — the trailing recompute is delayed,
+	* never cancelled.
+	*/
+	let cooldownUntil = 0;
+	const fire = () => {
+		if (timer) clearTimeout(timer);
+		const wait = Math.max(debounceMs, cooldownUntil - Date.now());
+		timer = setTimeout(() => {
+			timer = null;
+			const started = Date.now();
+			Promise.resolve().then(onChange).catch((err) => {
+				console.error(`[diffo] changeset refresh failed: ${err.message}`);
+			}).finally(() => {
+				const ended = Date.now();
+				cooldownUntil = ended + Math.min(ended - started, MAX_COOLDOWN_MS);
+			});
+		}, wait);
+	};
+	let watcher = null;
+	/**
+	* A watcher that cannot run gives up its handle and says so **once**, and the
+	* server keeps answering with a changeset that no longer refreshes itself. Logging
+	* per failure is what turned an EMFILE into 7,549 identical lines.
+	*/
+	const giveUp = (err) => {
+		if (!watcher) return;
+		watcher.close();
+		watcher = null;
+		console.error(`[diffo] live updates off — file watcher failed: ${err.message}\n[diffo] the review still serves; reload after a change to see it.`);
+	};
+	try {
+		watcher = watch(root, {
+			recursive: true,
+			persistent: true
+		});
+		watcher.on("change", (_event, filename) => {
+			if (filename == null) return fire();
+			if (affectsDiff(String(filename))) fire();
+		});
+		watcher.on("error", giveUp);
+	} catch (err) {
+		giveUp(err);
+	}
+	return () => {
+		if (timer) clearTimeout(timer);
+		watcher?.close();
+		watcher = null;
+	};
+}
+//#endregion
+//#region src/server/index.ts
+/** Types the UI embeds in <img>/srcset — the only repo content that may keep
+* its real MIME on `/api/file`. `.svg` can carry script, so every `/api/file`
+* response also gets `Content-Security-Policy: sandbox`: a direct navigation
+* renders it scriptless in an opaque origin, while <img> decoding is untouched. */
+const IMAGE_MIME = {
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".bmp": "image/bmp",
+	".avif": "image/avif",
+	".ico": "image/x-icon"
+};
+const MIME = {
+	".html": "text/html",
+	".js": "application/javascript",
+	".css": "text/css",
+	".woff2": "font/woff2",
+	...IMAGE_MIME
+};
+/** Whitespace heartbeats keep a long poll alive through proxies and idle
+* timeouts — the final JSON parses fine after them. */
+const POLL_HEARTBEAT_MS = 15e3;
+/**
+* How long one `diffo poll` may wait before being sent away to try again.
+* Bounds the *connection*, not the agent's patience: a half-open socket never
+* aborts, and a listening poll blocks the daemon's idle reap.
+*/
+const POLL_MAX_MS = 18e5;
+function createApp(ctx, store, review, queue) {
+	const app = new Hono();
+	if (review && queue) queue.onBatchClosed((closed) => {
+		if (closed.unanswered.length > 0) review.markUnanswered(closed.unanswered);
+	});
+	const LOOPBACK = /* @__PURE__ */ new Set([
+		"localhost",
+		"127.0.0.1",
+		"[::1]",
+		"::1"
+	]);
+	const isLoopbackHost = (value) => {
+		const host = value.startsWith("[") ? value.replace(/^(\[[^\]]*\])(?::\d+)?$/, "$1") : value.replace(/:\d+$/, "");
+		return LOOPBACK.has(host.toLowerCase());
+	};
+	app.use("*", async (c, next) => {
+		const host = c.req.header("host") ?? new URL(c.req.url).host;
+		if (!isLoopbackHost(host)) return c.text("Forbidden: unexpected Host header", 403);
+		const origin = c.req.header("origin");
+		if (origin !== void 0) {
+			let originHost;
+			try {
+				originHost = new URL(origin).hostname;
+			} catch {
+				return c.text("Forbidden: malformed Origin", 403);
+			}
+			if (!LOOPBACK.has(originHost.toLowerCase())) return c.text("Forbidden: cross-origin request", 403);
+		}
+		return next();
+	});
+	const parseSessionPid = (raw) => {
+		if (!raw) return null;
+		const pid = Number.parseInt(raw, 10);
+		return Number.isInteger(pid) && pid > 1 ? pid : null;
+	};
+	app.use("*", async (_c, next) => {
+		ctx.idle?.touch();
+		return next();
+	});
+	app.get("/api/health", (c) => c.json({
+		ok: true,
+		repo: resolve(ctx.root),
+		app: "diffo",
+		version: VERSION,
+		pid: process.pid
+	}));
+	app.post("/api/shutdown", (c) => {
+		setImmediate(() => ctx.onShutdownRequest?.());
+		return c.json({
+			ok: true,
+			note: "shutting down"
+		});
+	});
+	const repoInfo = () => store?.get().repo ?? {
+		path: resolve(ctx.root),
+		name: "",
+		branch: "",
+		worktree: null
+	};
+	const promptCtx = (...excludeThreadIds) => ({
+		repo: repoInfo(),
+		changeset: store?.get() ?? null,
+		siblings: review?.get().threads.filter((t) => !excludeThreadIds.includes(t.id) && (t.state === "open" || t.state === "sent")) ?? []
+	});
+	const deliverThreads = (threadIds) => {
+		if (!queue) return false;
+		const live = queue.hasListener();
+		queue.enqueueThreads(threadIds);
+		return live;
+	};
+	app.get("/api/review", (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		return c.json(review.get());
+	});
+	/** Where an agent thread lands: the hunk showing its new-side line, else its
+	* file, else the changeset — the same fallback ladder rendered threads use. */
+	const agentAnchor = (file, line) => {
+		if (file === null) return { kind: "changeset" };
+		const inChangeset = (store?.get().files ?? []).find((f) => f.path === file);
+		if (inChangeset && line !== null) {
+			for (const hunk of inChangeset.hunks) if (hunk.lines.some((l) => l.kind !== "del" && l.newNo === line)) return {
+				kind: "hunk",
+				hunkId: hunk.id,
+				path: file,
+				side: "new",
+				line
+			};
+		}
+		return inChangeset ? {
+			kind: "file",
+			path: file
+		} : { kind: "changeset" };
+	};
+	app.post("/api/review/threads", async (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const body = await c.req.json().catch(() => null);
+		const text = typeof body?.text === "string" ? body.text.trim() : "";
+		if (!text) return c.json({ error: "need {anchor, text}" }, 400);
+		if (body?.author === "agent") {
+			const file = typeof body?.file === "string" && body.file.trim() !== "" ? body.file.trim() : null;
+			const line = typeof body?.line === "number" && Number.isInteger(body.line) && body.line >= 1 ? body.line : null;
+			const anchor = agentAnchor(file, line);
+			const codeContext = anchor.kind === "hunk" && store ? snapshotHunk(store.get(), anchor.hunkId) : null;
+			return c.json(review.createThread(anchor, text, codeContext, void 0, "agent"));
+		}
+		const anchor = parseAnchor(body?.anchor);
+		if (!anchor) return c.json({ error: "need {anchor, text}" }, 400);
+		const intent = THREAD_INTENTS.includes(body?.intent) ? body.intent : void 0;
+		const codeContext = anchor.kind === "hunk" && store ? snapshotHunk(store.get(), anchor.hunkId) : null;
+		return c.json(review.createThread(anchor, text, codeContext, intent));
+	});
+	app.post("/api/review/threads/:id/messages", async (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const body = await c.req.json().catch(() => null);
+		const text = typeof body?.text === "string" ? body.text.trim() : "";
+		if (!text) return c.json({ error: "need {text}" }, 400);
+		if (body?.author === "agent") {
+			const id = c.req.param("id");
+			if (!review.get().threads.some((t) => t.id === id)) return c.json({ error: "no such thread" }, 404);
+			queue?.noteSession(parseSessionPid(c.req.header("x-diffo-session-pid")));
+			const waitedMs = queue?.agentReplied(id) ?? null;
+			const seenThroughMs = waitedMs === null ? void 0 : Date.now() - waitedMs;
+			const thread = review.addMessage(id, "agent", text, false, seenThroughMs);
+			if (!thread) return c.json({ error: "no such thread" }, 404);
+			if (waitedMs !== null) review.annotateAgentReplies([thread.id], waitedMs);
+			return c.json({
+				thread,
+				delivered: false
+			});
+		}
+		const deliver = body?.deliver !== false;
+		let thread = review.addMessage(c.req.param("id"), "reviewer", text, !deliver);
+		if (!thread) return c.json({ error: "no such thread" }, 404);
+		let delivered = false;
+		if (deliver && (thread.state === "sent" || thread.state === "addressed")) {
+			delivered = deliverThreads([thread.id]);
+			review.clearWithheld([thread.id]);
+			thread = review.get().threads.find((t) => t.id === thread.id) ?? thread;
+		}
+		return c.json({
+			thread,
+			delivered,
+			presence: queue?.presence() ?? "waiting"
+		});
+	});
+	app.post("/api/review/threads/:id/state", async (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const state = (await c.req.json().catch(() => null))?.state;
+		if (state !== "open" && state !== "resolved") return c.json({ error: "state must be \"resolved\" or \"open\" (reopen)" }, 400);
+		const thread = review.setState(c.req.param("id"), state);
+		return thread ? c.json(thread) : c.json({ error: "no such thread" }, 404);
+	});
+	app.delete("/api/review/threads", (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const removed = review.reset();
+		for (const id of removed) queue?.drop(id);
+		return c.json({ removed: removed.length });
+	});
+	app.delete("/api/review/landed", (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		review.clearLanded();
+		return c.json({ ok: true });
+	});
+	app.delete("/api/review/threads/:id", (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const id = c.req.param("id");
+		if (!review.removeThread(id)) return c.json({ error: "no such thread" }, 404);
+		queue?.drop(id);
+		return c.json({ removed: true });
+	});
+	app.post("/api/review/threads/:id/send", (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const thread = review.send(c.req.param("id"));
+		if (!thread) return c.json({ error: "no such thread" }, 404);
+		const prompt = buildThreadPrompt(thread, promptCtx(thread.id));
+		const presence = queue?.presence() ?? "waiting";
+		const handedOver = thread.state === "sent" || thread.state === "addressed" && thread.withheld === true;
+		const delivered = handedOver ? deliverThreads([thread.id]) : false;
+		if (handedOver) review.clearWithheld([thread.id]);
+		return c.json({
+			thread,
+			prompt,
+			delivered,
+			presence
+		});
+	});
+	/** Coverage off the wire: a real 0 must not read as "absent" (which
+	* `Number(x) || 0` would), and NaN-shaped garbage must not read as a number. */
+	const parseCoverage = (raw) => {
+		const src = raw ?? {};
+		const count = (value) => {
+			const n = Number(value);
+			return Number.isFinite(n) ? n : void 0;
+		};
+		const verdict = REVIEW_VERDICTS.includes(src.verdict) ? src.verdict : void 0;
+		const note = typeof src.note === "string" && src.note.trim() !== "" ? src.note.trim().slice(0, 4e3) : void 0;
+		const fileList = (value) => Array.isArray(value) ? value.filter((f) => typeof f === "string") : void 0;
+		const changedFiles = fileList(src.changedFiles);
+		const commentedUnread = fileList(src.commentedUnread);
+		return {
+			viewedHunks: count(src.viewedHunks) ?? 0,
+			totalHunks: count(src.totalHunks) ?? 0,
+			viewedFiles: count(src.viewedFiles),
+			totalFiles: count(src.totalFiles),
+			skippedFiles: fileList(src.skippedFiles) ?? [],
+			...changedFiles !== void 0 ? { changedFiles } : {},
+			...commentedUnread !== void 0 ? { commentedUnread } : {},
+			...verdict !== void 0 ? { verdict } : {},
+			...note !== void 0 ? { note } : {}
+		};
+	};
+	const activeThreads = (threads) => threadsInChangeset(store?.get().files ?? [], threads).active;
+	const flushableIds = (threads) => new Set(activeThreads(threads).filter((t) => !untouchedAgentVoice(t)).map((t) => t.id));
+	const projectFinish = (threads) => {
+		const flushable = flushableIds(threads);
+		return threads.map((t) => t.state === "open" && flushable.has(t.id) ? {
+			...t,
+			state: "sent"
+		} : t);
+	};
+	/**
+	* A closing note only becomes a thread while the changeset still has files to
+	* anchor it to — an empty diff would file it straight into the past, where the
+	* reviewer can't see it and the agent is never given it. In that case the note
+	* stays prose in the prompt (`buildFinishPrompt` quotes it when no thread carries
+	* it), which is all it ever was.
+	*/
+	const notable = (coverage) => coverage.note !== void 0 && (store?.get().files.length ?? 0) > 0;
+	/** The preview must show the note the same way Finish will send it — a thread in
+	* the batch — without writing one for a review the reviewer may still walk away
+	* from. */
+	const projectClosingNote = (threads, coverage) => {
+		if (!notable(coverage)) return threads;
+		const at = (/* @__PURE__ */ new Date()).toISOString();
+		return [...threads, {
+			id: "closing-note-preview",
+			anchor: { kind: "changeset" },
+			state: "sent",
+			closingNote: true,
+			codeContext: null,
+			codeChanged: false,
+			messages: [{
+				id: "closing-note-preview-message",
+				author: "reviewer",
+				text: coverage.note,
+				at
+			}],
+			createdAt: at,
+			updatedAt: at
+		}];
+	};
+	const outgoing = (projected, before) => projected.filter((t) => t.state === "sent").map((t) => ({
+		id: t.id,
+		anchor: t.anchor,
+		text: t.messages[0]?.text ?? "",
+		fresh: (before.find((b) => b.id === t.id)?.state ?? "open") === "open"
+	}));
+	app.post("/api/review/finish/preview", async (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const body = await c.req.json().catch(() => null);
+		const coverage = parseCoverage(body?.coverage);
+		const before = review.get().threads;
+		const batch = projectClosingNote(activeThreads(projectFinish(before)), coverage);
+		return c.json({
+			outgoing: outgoing(batch, before),
+			prompt: buildFinishPrompt(batch, {
+				repo: repoInfo(),
+				changeset: store?.get() ?? null
+			}, coverage)
+		});
+	});
+	app.post("/api/review/finish", async (c) => {
+		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const body = await c.req.json().catch(() => null);
+		const coverage = parseCoverage(body?.coverage);
+		const deliver = body?.deliver !== false;
+		if (notable(coverage)) review.closingNote(coverage.note);
+		const threads = review.finish(flushableIds(review.get().threads));
+		const batch = activeThreads(threads);
+		review.recordFinish((store?.get().files ?? []).flatMap((f) => f.hunks.map((h) => h.id)), coverage);
+		const prompt = buildFinishPrompt(batch, {
+			repo: repoInfo(),
+			changeset: store?.get() ?? null
+		}, coverage);
+		const presence = queue?.presence() ?? "waiting";
+		let delivered = false;
+		if (queue && deliver) {
+			delivered = queue.hasListener();
+			queue.enqueueFinish(coverage);
+		}
+		review.clearWithheld(batch.map((t) => t.id));
+		return c.json({
+			threads: review.get().threads,
+			prompt,
+			delivered,
+			presence
+		});
+	});
+	const pollPayload = (snapshot) => {
+		const threads = review?.get().threads ?? [];
+		if (snapshot.kind === "finish") {
+			const batch = activeThreads(threads);
+			return {
+				status: "feedback",
+				kind: "finish",
+				threadIds: batch.filter((t) => t.state === "sent").map((t) => t.id),
+				prompt: buildFinishPrompt(batch, {
+					repo: repoInfo(),
+					changeset: store?.get() ?? null
+				}, snapshot.coverage)
+			};
+		}
+		const delivered = threads.filter((t) => snapshot.threadIds.includes(t.id));
+		const prompt = delivered.length === 1 ? buildThreadPrompt(delivered[0], promptCtx(delivered[0].id)) : buildCoalescedPrompt(delivered, promptCtx(...snapshot.threadIds));
+		return {
+			status: "feedback",
+			kind: "threads",
+			threadIds: delivered.map((t) => t.id),
+			prompt
+		};
+	};
+	app.get("/api/agent/poll", (c) => {
+		if (!review || !queue) return c.json({ error: "review unavailable" }, 503);
+		if (!c.req.header("x-diffo-agent") && !c.req.header("x-diffo-session-pid")) return c.json({ error: "agent polls must send the x-diffo-agent header — use `diffo poll`" }, 403);
+		const tookOverFrom = queue.claimSession(parseSessionPid(c.req.header("x-diffo-session-pid")));
+		if (tookOverFrom !== null) c.header("x-diffo-took-over-from", String(tookOverFrom));
+		const heartbeatMs = ctx.pollHeartbeatMs ?? POLL_HEARTBEAT_MS;
+		return stream(c, async (s) => {
+			let aborted = false;
+			let detach = null;
+			const release = () => detach?.();
+			ctx.idle?.connect();
+			let counted = true;
+			const drop = () => {
+				if (!counted) return;
+				counted = false;
+				ctx.idle?.disconnect();
+			};
+			s.onAbort(() => {
+				aborted = true;
+				release();
+				drop();
+			});
+			try {
+				const deadline = Date.now() + (ctx.pollMaxMs ?? POLL_MAX_MS);
+				while (!aborted) {
+					let settled = false;
+					const attach = queue.attach((d) => detach = d).then((outcome) => {
+						settled = true;
+						return outcome;
+					});
+					while (!settled && !aborted && Date.now() < deadline) {
+						const nap = Math.min(heartbeatMs, deadline - Date.now());
+						await Promise.race([attach, new Promise((r) => setTimeout(r, nap))]);
+						if (!settled && !aborted) await s.write(" ");
+					}
+					if (aborted) return;
+					if (!settled) {
+						release();
+						await s.write(JSON.stringify({
+							status: "timeout",
+							message: "no feedback within the poll window — nothing is lost; re-run `diffo poll` to keep listening"
+						}));
+						return;
+					}
+					const outcome = await attach;
+					if (outcome === "gone") return;
+					if (outcome === "superseded") {
+						await s.write(JSON.stringify({
+							status: "superseded",
+							message: "another poll attached for this repo — this one is released. The newer poll carries the review now, so do nothing here and do not re-poll unless the user asks. If that was not you, another agent session is on this repo: say so, so the user knows where their feedback is going."
+						}));
+						return;
+					}
+					if (outcome === "ended") {
+						await s.write(JSON.stringify({
+							status: "ended",
+							message: "the agent detached (`diffo end`) — do not re-poll unless asked; deliver anything remaining directly in the conversation"
+						}));
+						return;
+					}
+					const snapshot = queue.take();
+					if (!snapshot) continue;
+					const inner = pollPayload(snapshot);
+					const payload = {
+						...inner,
+						next_step: nextStepFor(inner.kind, inner.threadIds.length)
+					};
+					await s.write(JSON.stringify(payload));
+					if (aborted) return;
+					queue.confirm(snapshot, payload.threadIds);
+					review.markDelivered(payload.threadIds);
+					review.clearUnanswered(payload.threadIds);
+					if (snapshot.kind === "finish") review.markFinishCollected();
+					return;
+				}
+			} finally {
+				drop();
+			}
+		});
+	});
+	app.post("/api/agent/end", (c) => {
+		if (!queue) return c.json({ error: "agent queue unavailable" }, 503);
+		const sessionPid = parseSessionPid(c.req.header("x-diffo-session-pid"));
+		if (queue.end(sessionPid)) return c.json({ ok: true });
+		return c.json({
+			ok: false,
+			reason: "not-owner",
+			ownerPid: queue.ownerPid(),
+			message: "this review belongs to another agent session — nothing was detached, and that session's poll is untouched"
+		});
+	});
+	app.get("/api/agent/invite", (c) => c.json({
+		install: INSTALL_SKILL,
+		join: JOIN_PROMPT,
+		presence: queue?.presence() ?? "waiting"
+	}));
+	app.get("/api/changeset", (c) => {
+		try {
+			return c.json(store ? store.get() : new ChangesetStore(ctx.root, ctx.spec).get());
+		} catch (err) {
+			if (err instanceof MissingBaseError) return c.json({ error: err.message }, 400);
+			throw err;
+		}
+	});
+	app.get("/api/file", (c) => {
+		const path = c.req.query("path");
+		const side = c.req.query("side");
+		if (!path || side !== "base" && side !== "head") return c.json({ error: "need ?path= and ?side=base|head" }, 400);
+		let bytes;
+		try {
+			bytes = side === "head" ? getHeadFileBytes(ctx.root, path) : getBaseFileBytes(ctx.root, resolveBaseRef(ctx.root, ctx.spec), path);
+		} catch (err) {
+			if (err instanceof MissingBaseError) return c.json({ error: err.message }, 400);
+			throw err;
+		}
+		if (bytes === null) return c.json({ error: "no such file on that side" }, 404);
+		const mime = IMAGE_MIME[extname(path)] ?? "text/plain; charset=utf-8";
+		return c.body(new Uint8Array(bytes), 200, {
+			"Content-Type": mime,
+			"Content-Security-Policy": "sandbox",
+			"X-Content-Type-Options": "nosniff"
+		});
+	});
+	app.get("/api/events", (c) => streamSSE(c, async (sse) => {
+		if (!store) {
+			await sse.close();
+			return;
+		}
+		let id = 0;
+		let closed = false;
+		ctx.idle?.connect();
+		let counted = true;
+		const drop = () => {
+			if (!counted) return;
+			counted = false;
+			ctx.idle?.disconnect();
+		};
+		const unsubscribe = store.subscribe((changeset) => {
+			sse.writeSSE({
+				event: "changeset",
+				data: JSON.stringify({ version: changeset.version }),
+				id: String(id++)
+			});
+		});
+		const unsubscribeReview = review?.subscribe(() => {
+			sse.writeSSE({
+				event: "review",
+				data: "{}",
+				id: String(id++)
+			});
+		});
+		const unsubscribePresence = queue?.subscribe(() => {
+			sse.writeSSE({
+				event: "presence",
+				data: JSON.stringify({
+					...queue.presenceDetail(),
+					workingOn: queue.deliveredThreadIds(),
+					queued: queue.queuedThreadIds(),
+					answered: queue.currentBatch()?.answered ?? []
+				}),
+				id: String(id++)
+			});
+		});
+		sse.onAbort(() => {
+			closed = true;
+			drop();
+			unsubscribe();
+			unsubscribeReview?.();
+			unsubscribePresence?.();
+		});
+		await sse.writeSSE({
+			event: "changeset",
+			data: JSON.stringify({ version: store.get().version }),
+			id: String(id++)
+		});
+		if (queue) await sse.writeSSE({
+			event: "presence",
+			data: JSON.stringify({
+				...queue.presenceDetail(),
+				workingOn: queue.deliveredThreadIds(),
+				queued: queue.queuedThreadIds(),
+				answered: queue.currentBatch()?.answered ?? []
+			}),
+			id: String(id++)
+		});
+		while (!closed) {
+			await sse.sleep(15e3);
+			await sse.writeSSE({
+				event: "ping",
+				data: ""
+			});
+		}
+	}));
+	const serveIndex = async (c) => {
+		try {
+			const index = await readFile(resolve(ctx.clientDir, "index.html"));
+			return c.html(markDevIndex(index.toString(), IS_DEV));
+		} catch {
+			return c.text("Client not built — run `pnpm build`", 404);
+		}
+	};
+	app.get("/*", async (c) => {
+		const requested = c.req.path === "/" ? "index.html" : c.req.path.slice(1);
+		const fullPath = resolve(ctx.clientDir, requested);
+		if (!fullPath.startsWith(resolve(ctx.clientDir) + sep)) return c.text("Forbidden", 403);
+		if (resolve(fullPath) === resolve(ctx.clientDir, "index.html")) return serveIndex(c);
+		try {
+			const content = await readFile(fullPath);
+			const mime = MIME[extname(fullPath)] ?? "application/octet-stream";
+			return c.body(new Uint8Array(content), 200, { "Content-Type": mime });
+		} catch {
+			return serveIndex(c);
+		}
+	});
+	return app;
+}
+/**
+* A review served from a source checkout has to LOOK like one. The reviewer may
+* have the shipped `/diffo` open in another tab, and nothing else on the page
+* distinguishes them — same UI, same repo, same diff. The title carries it into
+* the tab strip; the meta tag lets the header render a badge without an extra
+* round trip, so there is no flash of a review that looks released.
+*/
+function markDevIndex(html, isDev) {
+	if (!isDev || html.includes("name=\"diffo-env\"")) return html;
+	return html.replace(/<title>[^<]*<\/title>/, "<title>diffo-dev</title>").replace(/<\/head>/, "    <meta name=\"diffo-env\" content=\"development\" />\n  </head>");
+}
+function rehydrateQueue(review, queue) {
+	const state = review.get();
+	queue.enqueueThreads(undeliveredThreadIds(state.threads));
+	const finish = state.lastFinish;
+	if (finish && !finish.collectedAt) queue.enqueueFinish(finish.coverage);
+}
+var RepoAlreadyServedError = class extends Error {
+	holder;
+	constructor(holder) {
+		super(`diffo is already serving this repo on port ${holder.port}`);
+		this.holder = holder;
+		this.name = "RepoAlreadyServedError";
+	}
+};
+function startServer(options) {
+	const store = new ChangesetStore(options.root, options.spec);
+	const db = new DiffoDb();
+	const { claimed, holder } = db.claimServer(resolve(options.root), options.port, process.pid);
+	if (!claimed) {
+		db.close();
+		throw new RepoAlreadyServedError(holder);
+	}
+	db.setPreferredPort(resolve(options.root), options.port);
+	const review = new ReviewStore(options.root, db, options.spec);
+	const queue = new DeliveryQueue();
+	queue.rescope(store.get().repo.branch);
+	rehydrateQueue(review, queue);
+	const log = (message) => console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: false })}] ${message}`);
+	queue.subscribe((presence) => log(`agent ${presence}`));
+	const unsubscribeBatch = queue.onBatchClosed((closed) => {
+		const took = Math.round((closed.closedAt - closed.deliveredAt) / 1e3);
+		log(`agent finished a batch of ${closed.threadIds.length} in ${took}s (${closed.reason})` + (closed.unanswered.length > 0 ? ` — ${closed.unanswered.length} unanswered` : ""));
+	});
+	const landedGit = {
+		head: () => getHeadSha(options.root),
+		isAncestor: (ancestor, descendant) => isAncestor(options.root, ancestor, descendant),
+		subject: (sha) => getCommitSubject(options.root, sha)
+	};
+	const checkLanded = (hasFiles) => {
+		if (maintainLanded(review, hasFiles, landedGit) === "stamped") {
+			const landed = review.get().landed;
+			if (landed) log(`changeset landed in ${landed.sha.slice(0, 7)} — offering a fresh review`);
+		}
+	};
+	const stopWatching = watchRepo(options.root, () => store.refresh());
+	const unsubscribeReconcile = store.subscribe((changeset) => {
+		const before = review.scope.branch;
+		review.rescope(changeset.repo.branch);
+		queue.rescope(changeset.repo.branch);
+		if (review.scope.branch !== before) log(`branch ${before || "detached"} → ${changeset.repo.branch || "detached"}`);
+		review.reconcile(new Set(changeset.files.flatMap((f) => f.hunks.map((h) => h.id))));
+		checkLanded(changeset.files.length > 0);
+	});
+	review.reconcile(new Set(store.get().files.flatMap((f) => f.hunks.map((h) => h.id))));
+	checkLanded(store.get().files.length > 0);
+	const idleTimeoutMs = resolveIdleTimeoutMs(process.env);
+	let idle;
+	if (idleTimeoutMs !== null) {
+		idle = new IdleMonitor({
+			timeoutMs: idleTimeoutMs,
+			onIdle: () => {
+				log(`idle for ${Math.round(idleTimeoutMs / 6e4)}m with no browser or agent — shutting down`);
+				process.exit(0);
+			}
+		});
+		idle.start();
+	}
+	const app = createApp({
+		...options,
+		idle,
+		onShutdownRequest: options.onShutdownRequest ?? (() => process.exit(0))
+	}, store, review, queue);
+	const server = serve({
+		fetch: app.fetch,
+		port: options.port,
+		hostname: "127.0.0.1"
+	});
+	const deregister = () => {
+		try {
+			db.removeServer(review.repoPath, options.port);
+		} catch {}
+	};
+	process.once("exit", deregister);
+	server.on("error", (err) => {
+		deregister();
+		if (options.onListenError) return options.onListenError(err);
+		console.error(err.code === "EADDRINUSE" ? `diffo: port ${options.port} was taken while starting up — re-run to pick another` : `diffo: cannot listen on port ${options.port} — ${err.message}`);
+		process.exit(1);
+	});
+	return {
+		server,
+		store,
+		review,
+		queue,
+		stopWatching: async () => {
+			idle?.stop();
+			unsubscribeReconcile();
+			unsubscribeBatch();
+			await stopWatching();
+			deregister();
+			process.removeListener("exit", deregister);
+			db.close();
+		}
+	};
+}
+//#endregion
+//#region src/serverUrl.ts
+/**
+* Every URL that reaches a review server is built here, and nowhere else.
+* Two names on purpose — `apiUrl` is what the CLI speaks over HTTP, `reviewUrl`
+* is what a human opens — so the managed version can swap either base (a remote
+* host, auth in the URL) without touching a call site. The listen host in
+* `src/server/index.ts` is the other side of this seam and stays separate: it
+* says where the local server binds, not how anything reaches it.
+*/
+function apiUrl(port, path = "") {
+	return `http://127.0.0.1:${port}${path}`;
+}
+function reviewUrl(port) {
+	return `http://localhost:${port}`;
+}
+//#endregion
+//#region src/serverLifecycle.ts
+const MAX_LOG_BYTES = 2097152;
+function assessRunningServer(health, repoPath, version) {
+	if (health?.ok !== true || health.repo !== repoPath) return "foreign";
+	return health.app === "diffo" && health.version === version ? "reuse" : "replace";
+}
+/**
+* argv for the daemon: the same runtime flags executing this CLI, the same entry
+* script, headless. `--foreground` is not a contradiction — it means "hold the
+* server in THIS process", and without it the child would spawn another one of
+* itself, forever.
+*/
+function serverSpawnArgs(entry, execArgv, port, base) {
+	const args = [
+		...execArgv,
+		entry,
+		"--no-open",
+		"--foreground"
+	];
+	if (port !== void 0) args.push("-p", String(port));
+	if (base !== void 0) args.push("--base", base);
+	return args;
+}
+async function fetchHealth(port, timeoutMs = 1500) {
+	try {
+		const res = await fetch(apiUrl(port, "/api/health"), { signal: AbortSignal.timeout(timeoutMs) });
+		if (!res.ok) return null;
+		return await res.json();
+	} catch {
+		return null;
+	}
+}
+async function delay(ms) {
+	await new Promise((r) => setTimeout(r, ms));
+}
+async function waitUntil(predicate, timeoutMs, stepMs = 120) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (await predicate()) return true;
+		await delay(stepMs);
+	}
+	return predicate();
+}
+/**
+* Retire a server we own: ask nicely over HTTP, and only if it lingers (a
+* pre-shutdown-endpoint build 404s the POST) fall back to SIGTERM.
+*
+* The health check proves the *port* belongs to this repo's diffo; the pid comes
+* from the registry, and after a crash and a pid reuse it can name something else.
+* So the signal is only sent when the server itself named the same pid — except on
+* builds that report no pid, where the registry's stays the fallback.
+*/
+async function retireServer(port, pid, reportedPid = null) {
+	try {
+		await fetch(apiUrl(port, "/api/shutdown"), {
+			method: "POST",
+			signal: AbortSignal.timeout(1500)
+		});
+	} catch {}
+	const gone = () => fetchHealth(port).then((h) => h === null);
+	if (await waitUntil(gone, 2e3)) return true;
+	if (pid !== null && (reportedPid === null || reportedPid === pid)) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {}
+		return waitUntil(gone, 3e3);
+	}
+	return false;
+}
+/**
+* Look up this repo's registered server and settle its fate: a healthy same-build
+* server is returned for reuse; a server from another build is retired; a stale
+* row (dead port, or a foreign squatter) is cleared. Returns null once the
+* registry holds no reusable server. Throws when an other-build server would not
+* step aside — the row is NOT cleared then: two servers on one review each hold
+* their own copy and write the whole blob back, so the slower watcher erases the
+* reviewer's threads, and clearing the row would hand the claim to a newcomer.
+*/
+async function settleExistingServer(db, repoPath, version, onStatus = () => {}) {
+	const record = db.getServer(repoPath);
+	if (!record) return null;
+	const health = await fetchHealth(record.port);
+	const verdict = assessRunningServer(health, repoPath, version);
+	if (verdict === "reuse") return {
+		port: record.port,
+		pid: health?.pid ?? record.pid ?? null
+	};
+	if (verdict === "replace") {
+		onStatus(`replacing the diffo server from another build (${health?.version ?? "pre-handshake"} → ${version})`);
+		if (!await retireServer(record.port, record.pid ?? null, health?.pid ?? null)) throw new Error(`a diffo server from another build is stuck on port ${record.port}` + (record.pid ? ` (pid ${record.pid})` : "") + ` and would not step aside — stop it, then re-run`);
+	}
+	db.removeServer(repoPath, record.port);
+	return null;
+}
+function defaultLogPath(repoPath) {
+	const abs = resolve(repoPath);
+	const hash = createHash("sha256").update(abs).digest("hex").slice(0, 8);
+	return join(homedir(), ".diffo", "logs", `${basename(abs)}-${hash}.log`);
+}
+function rotateLog(logPath) {
+	try {
+		if (statSync(logPath).size < MAX_LOG_BYTES) return;
+		renameSync(logPath, `${logPath}.1`);
+	} catch {}
+}
+function logSize(logPath) {
+	try {
+		return statSync(logPath).size;
+	} catch {
+		return 0;
+	}
+}
+/**
+* The daemon's own last word — only what THIS spawn appended (past `from`),
+* preferring its `diffo:` lines — so a failed handshake names the reason
+* instead of pointing at a file.
+*/
+function daemonComplaint(logPath, from) {
+	try {
+		const lines = readFileSync(logPath).subarray(from).toString("utf-8").split("\n").map((line) => line.trim()).filter(Boolean);
+		const line = lines.filter((l) => l.startsWith("diffo: ")).at(-1) ?? lines.at(-1);
+		return line ? line.replace(/^diffo: /, "").slice(0, 300) : null;
+	} catch {
+		return null;
+	}
+}
+function spawnDaemonProcess(opts) {
+	mkdirSync(dirname(opts.logPath), { recursive: true });
+	rotateLog(opts.logPath);
+	const logFd = openSync(opts.logPath, "a");
+	spawn(opts.execPath, serverSpawnArgs(opts.entry, opts.execArgv, opts.port, opts.base), {
+		cwd: opts.repoPath,
+		detached: true,
+		stdio: [
+			"ignore",
+			logFd,
+			logFd
+		],
+		env: {
+			...opts.env ?? process.env,
+			DIFFO_DAEMON: "1"
+		}
+	}).unref();
+}
+async function ensureServer(opts, deps = {}) {
+	const status = opts.onStatus ?? (() => {});
+	const db = new DiffoDb(opts.dbPath);
+	try {
+		const existing = await settleExistingServer(db, opts.repoPath, opts.version, status);
+		if (existing) return existing.port;
+		status("no diffo server for this repo — starting one");
+		mkdirSync(dirname(opts.logPath), { recursive: true });
+		rotateLog(opts.logPath);
+		const logStart = logSize(opts.logPath);
+		(deps.spawnDaemon ?? spawnDaemonProcess)(opts);
+		let port = null;
+		if (!await waitUntil(async () => {
+			const row = db.getServer(opts.repoPath);
+			if (!row) return false;
+			if (assessRunningServer(await fetchHealth(row.port, 500), opts.repoPath, opts.version) !== "reuse") return false;
+			port = row.port;
+			return true;
+		}, opts.spawnTimeoutMs ?? 8e3) || port === null) {
+			const complaint = daemonComplaint(opts.logPath, logStart);
+			throw new Error(complaint ? `the diffo server did not start: ${complaint} (log: ${opts.logPath})` : `the diffo server did not start — see ${opts.logPath}`);
+		}
+		return port;
+	} finally {
+		db.close();
+	}
+}
+//#endregion
+//#region src/setup.ts
+/**
+* What a freshly registered client needs before diffo shows up in it. Skill
+* files are read per session, so those clients need no restart; Cursor scans
+* local plugins at startup and Reload Window is unreliable for it; VS Code
+* reads chat.pluginLocations on window load.
+*/
+const postRegisterHint = {
+	"claude-code": "available in new agent sessions",
+	"agents-dir": "available in new agent sessions",
+	cursor: "restart Cursor to load it",
+	vscode: "reload the VS Code window to load it",
+	copilot: "available in new copilot sessions"
+};
+function isDiffoSkill(content) {
+	const frontmatter = /^---\n([\s\S]*?)\n---/.exec(content)?.[1] ?? "";
+	return /^name:\s*diffo\s*$/m.test(frontmatter);
+}
+function pluginName(packageRoot) {
+	try {
+		const manifest = JSON.parse(readFileSync(join(packageRoot, "plugin.json"), "utf-8"));
+		if (typeof manifest.name === "string" && manifest.name !== "") return manifest.name;
+	} catch {}
+	return "diffo";
+}
+const collapse = (target, home) => home && target.startsWith(home) ? `~${target.slice(home.length)}` : target;
+function packagedSkill(ctx) {
+	return readFileSync(join(ctx.packageRoot, "skills", "diffo", "SKILL.md"), "utf-8");
+}
+function installSkillCopy(ctx, client, targetDir) {
+	const home = ctx.homeDir;
+	const content = packagedSkill(ctx);
+	const target = join(targetDir, "SKILL.md");
+	if (existsSync(target)) {
+		const existing = readFileSync(target, "utf-8");
+		if (existing === content) return {
+			client,
+			status: "current",
+			detail: collapse(target, home)
+		};
+		if (!isDiffoSkill(existing)) return {
+			client,
+			status: "manual",
+			detail: `a different skill lives at ${collapse(target, home)} — remove it and re-run \`diffo setup\``
+		};
+		writeFileSync(target, content);
+		return {
+			client,
+			status: "registered",
+			detail: collapse(target, home)
+		};
+	}
+	mkdirSync(targetDir, { recursive: true });
+	writeFileSync(target, content);
+	return {
+		client,
+		status: "registered",
+		detail: collapse(target, home)
+	};
+}
+function registerSkillsDir(ctx) {
+	const home = ctx.homeDir;
+	const client = "claude-code";
+	if (!existsSync(join(home, ".claude"))) return {
+		client,
+		status: "absent",
+		detail: "no ~/.claude directory found"
+	};
+	return installSkillCopy(ctx, client, join(home, ".claude", "skills", "diffo"));
+}
+/**
+* The cross-tool skills directory of the Agent Skills spec: Codex reads
+* `~/.agents/skills` as its user-level location, and Gemini CLI, Amp, Goose,
+* OpenCode and others follow the same convention. One copy covers them all.
+* `~/.codex` counts as presence too — Codex reads the directory without
+* creating it.
+*/
+function registerAgentsDir(ctx) {
+	const home = ctx.homeDir;
+	const client = "agents-dir";
+	if (!existsSync(join(home, ".agents")) && !existsSync(join(home, ".codex"))) return {
+		client,
+		status: "absent",
+		detail: "no ~/.agents (or ~/.codex) directory found"
+	};
+	return installSkillCopy(ctx, client, join(home, ".agents", "skills", "diffo"));
+}
+/** The dev skill drives a source checkout; a shipped CLI must never replace it. */
+const DEV_SKILL_MARKER = "This is a DEV build";
+/**
+* Freshen the file-copy skill installs. `npx -y @diffohq/diffo` resolves a current CLI
+* on every review, which makes the CLI the one component that is always fresh —
+* so it carries the installed skill forward, instead of every release waiting
+* on users to re-run `diffo setup`. Refresh only: it never installs anew, never
+* touches a skill that isn't ours, and never replaces a dev skill.
+*/
+function refreshInstalledSkills(ctx) {
+	if ((ctx.env ?? process.env).ENV === "development") return [];
+	let content;
+	try {
+		content = packagedSkill(ctx);
+	} catch {
+		return [];
+	}
+	const refreshed = [];
+	for (const target of [join(ctx.homeDir, ".claude", "skills", "diffo", "SKILL.md"), join(ctx.homeDir, ".agents", "skills", "diffo", "SKILL.md")]) try {
+		const existing = readFileSync(target, "utf-8");
+		if (existing === content) continue;
+		if (!isDiffoSkill(existing)) continue;
+		if (existing.includes(DEV_SKILL_MARKER)) continue;
+		writeFileSync(target, content);
+		refreshed.push(target);
+	} catch {}
+	return refreshed;
+}
+function registerCursor(ctx) {
+	const home = ctx.homeDir;
+	const platform = ctx.platform ?? process.platform;
+	const client = "cursor";
+	if (!existsSync(join(home, ".cursor"))) return {
+		client,
+		status: "absent",
+		detail: "no ~/.cursor directory found"
+	};
+	const localPlugins = join(home, ".cursor", "plugins", "local");
+	const target = join(localPlugins, pluginName(ctx.packageRoot));
+	const link = (to, at) => symlinkSync(to, at, platform === "win32" ? "junction" : "dir");
+	let existing = null;
+	try {
+		existing = lstatSync(target);
+	} catch {}
+	if (existing && !existing.isSymbolicLink()) return {
+		client,
+		status: "manual",
+		detail: `${collapse(target, home)} exists and is not a symlink — remove it and re-run \`diffo setup\``
+	};
+	if (existing) {
+		if (resolve(readlinkSync(target)) === ctx.packageRoot) return {
+			client,
+			status: "current",
+			detail: collapse(target, home)
+		};
+		const replacement = `${target}.${process.pid}.tmp`;
+		try {
+			link(ctx.packageRoot, replacement);
+			if (platform === "win32") rmSync(target, { force: true });
+			renameSync(replacement, target);
+		} catch (error) {
+			rmSync(replacement, { force: true });
+			return {
+				client,
+				status: "manual",
+				detail: `cannot link ${collapse(target, home)} (${error.message}) — link it to ${ctx.packageRoot} manually`
+			};
+		}
+		return {
+			client,
+			status: "registered",
+			detail: collapse(target, home)
+		};
+	}
+	mkdirSync(localPlugins, { recursive: true });
+	try {
+		link(ctx.packageRoot, target);
+	} catch (error) {
+		return {
+			client,
+			status: "manual",
+			detail: `cannot link ${collapse(target, home)} (${error.message}) — link it to ${ctx.packageRoot} manually`
+		};
+	}
+	return {
+		client,
+		status: "registered",
+		detail: collapse(target, home)
+	};
+}
+function vsCodeSettingsFile(env, homeDir, platform) {
+	if (platform === "win32") return join(env.APPDATA || join(homeDir, "AppData", "Roaming"), "Code", "User", "settings.json");
+	if (platform === "darwin") return join(homeDir, "Library", "Application Support", "Code", "User", "settings.json");
+	return join(env.XDG_CONFIG_HOME || join(homeDir, ".config"), "Code", "User", "settings.json");
+}
+function updatePluginLocations(settings, packageRoot, name) {
+	const updated = structuredClone(settings);
+	const existing = updated["chat.pluginLocations"];
+	const locations = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
+	let changed = false;
+	for (const key of Object.keys(locations)) {
+		if (key === packageRoot) continue;
+		let stale = false;
+		try {
+			stale = JSON.parse(readFileSync(join(key, "plugin.json"), "utf-8")).name === name;
+		} catch {
+			stale = !existsSync(key) && basename(key) === name;
+		}
+		if (stale) {
+			delete locations[key];
+			changed = true;
+		}
+	}
+	if (locations[packageRoot] !== true) {
+		locations[packageRoot] = true;
+		changed = true;
+	}
+	updated["chat.pluginLocations"] = locations;
+	return [updated, changed];
+}
+function registerVsCode(ctx) {
+	const home = ctx.homeDir;
+	const client = "vscode";
+	const settingsFile = vsCodeSettingsFile(ctx.env ?? process.env, home, ctx.platform ?? process.platform);
+	const hasFile = existsSync(settingsFile);
+	if (!hasFile && !existsSync(dirname(settingsFile))) return {
+		client,
+		status: "absent",
+		detail: "no VS Code user configuration found"
+	};
+	let settings = {};
+	if (hasFile) try {
+		settings = JSON.parse(readFileSync(settingsFile, "utf-8"));
+	} catch {
+		return {
+			client,
+			status: "manual",
+			detail: `add "chat.plugins.enabled": true and "chat.pluginLocations": {"${ctx.packageRoot}": true} to ${collapse(settingsFile, home)}`
+		};
+	}
+	const [updated, locationsChanged] = updatePluginLocations(settings, ctx.packageRoot, pluginName(ctx.packageRoot));
+	let changed = locationsChanged;
+	if (!("chat.plugins.enabled" in updated)) {
+		updated["chat.plugins.enabled"] = true;
+		changed = true;
+	}
+	if (!changed) return {
+		client,
+		status: "current",
+		detail: collapse(settingsFile, home)
+	};
+	try {
+		writeFileSync(settingsFile, `${JSON.stringify(updated, null, 2)}\n`);
+	} catch (error) {
+		return {
+			client,
+			status: "failed",
+			detail: error.message
+		};
+	}
+	return {
+		client,
+		status: "registered",
+		detail: collapse(settingsFile, home)
+	};
+}
+function registerCopilot(ctx) {
+	const client = "copilot";
+	const run = ctx.run ?? ((command, args) => spawnSync(command, args, { encoding: "utf-8" }));
+	const listed = run("copilot", [
+		"plugins",
+		"list",
+		"--scope",
+		"user",
+		"--kind",
+		"plugin",
+		"--json"
+	]);
+	if (listed.error) return {
+		client,
+		status: "absent",
+		detail: "copilot CLI not found on PATH"
+	};
+	const name = pluginName(ctx.packageRoot);
+	if (listed.status === 0) try {
+		const parsed = JSON.parse(listed.stdout);
+		if ((Array.isArray(parsed) ? parsed : Array.isArray(parsed?.plugins) ? parsed.plugins : []).find((r) => typeof r === "object" && r !== null && r.name === name && resolve(String(r.source ?? r.path ?? "")) === ctx.packageRoot)) return {
+			client,
+			status: "current",
+			detail: collapse(ctx.packageRoot, ctx.homeDir)
+		};
+	} catch {}
+	const installed = run("copilot", [
+		"plugin",
+		"install",
+		ctx.packageRoot
+	]);
+	if (installed.status !== 0) return {
+		client,
+		status: "failed",
+		detail: String(installed.stderr || installed.stdout || `exit ${installed.status}`).trim().split("\n")[0] ?? "plugin install failed"
+	};
+	return {
+		client,
+		status: "registered",
+		detail: "copilot plugin install"
+	};
+}
+function runSetup(ctx) {
+	return [
+		registerSkillsDir(ctx),
+		registerAgentsDir(ctx),
+		registerCursor(ctx),
+		registerVsCode(ctx),
+		registerCopilot(ctx)
+	];
+}
+//#endregion
+//#region src/cli.ts
+const command = parseCliArgs(process.argv.slice(2));
+function fail(message) {
+	console.error(`diffo: ${message}`);
+	process.exit(1);
+}
+function probePort(port) {
+	return new Promise((resolvePort, reject) => {
+		const probe = createServer();
+		probe.unref();
+		probe.once("error", reject);
+		probe.listen({
+			port,
+			host: "127.0.0.1"
+		}, () => {
+			const address = probe.address();
+			const bound = typeof address === "object" && address !== null ? address.port : port;
+			probe.close(() => resolvePort(bound));
+		});
+	});
+}
+async function preferredPort() {
+	const db = new DiffoDb();
+	let remembered;
+	try {
+		remembered = db.getPreferredPort(repoPath);
+	} finally {
+		db.close();
+	}
+	if (remembered === null) return probePort(0);
+	try {
+		return await probePort(remembered);
+	} catch {
+		return probePort(0);
+	}
+}
+function specLabel(spec) {
+	return spec.kind === "working-tree" ? "working tree vs HEAD" : `vs ${spec.base}`;
+}
+/** The platform's URL opener. `start` is a `cmd` builtin, not an executable. */
+function opener(url) {
+	if (process.platform === "darwin") return ["open", [url]];
+	if (process.platform === "win32") return ["cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]];
+	return ["xdg-open", [url]];
+}
+function openBrowser(url) {
+	const [command, args] = opener(url);
+	try {
+		const child = spawn(command, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.once("error", () => {});
+		child.unref();
+	} catch {}
+}
+if (command.kind === "error") {
+	console.error(`diffo: ${command.message}`);
+	console.error(`try: diffo --help`);
+	process.exit(1);
+}
+if (command.kind === "help") {
+	console.log(helpFor(command.topic));
+	process.exit(0);
+}
+if (command.kind === "version") {
+	console.log(VERSION);
+	process.exit(0);
+}
+if (command.kind === "setup") {
+	const outcomes = runSetup({
+		packageRoot: resolve(dirname(fileURLToPath(import.meta.url)), ".."),
+		homeDir: homedir()
+	});
+	const width = Math.max(...outcomes.map((o) => o.client.length));
+	for (const outcome of outcomes) {
+		const hint = outcome.status === "registered" ? postRegisterHint[outcome.client] : void 0;
+		console.log(`${outcome.client.padEnd(width)}  ${outcome.status.padEnd(10)}  ${outcome.detail}${hint ? ` — ${hint}` : ""}`);
+	}
+	if (outcomes.some((o) => o.status === "manual")) console.log("rows marked manual need the one step described; re-run `diffo setup` after");
+	if (outcomes.every((o) => o.status === "absent")) console.log("\nno supported client found — install one, then re-run `diffo setup`");
+	process.exit(outcomes.some((o) => o.status === "failed") ? 1 : 0);
+}
+const root = findRepoRoot(process.cwd());
+if (!root) fail("not inside a git repository");
+const repoPath = resolve(root);
+async function discoverServer() {
+	const db = new DiffoDb();
+	try {
+		return await settleExistingServer(db, repoPath, VERSION, (line) => process.stderr.write(`diffo: ${line}\n`));
+	} catch (err) {
+		fail(err.message);
+	} finally {
+		db.close();
+	}
+}
+function sessionHeaders() {
+	const pid = detectSessionPid();
+	return {
+		"x-diffo-agent": "cli",
+		...pid === null ? {} : { "x-diffo-session-pid": String(pid) }
+	};
+}
+async function requireServer(port, base) {
+	try {
+		return await ensureServer({
+			repoPath,
+			version: VERSION,
+			entry: resolve(process.argv[1] ?? fileURLToPath(import.meta.url)),
+			execPath: process.execPath,
+			execArgv: process.execArgv,
+			port,
+			base,
+			logPath: process.env.DIFFO_SERVER_LOG || defaultLogPath(repoPath),
+			onStatus: (line) => process.stderr.write(`diffo: ${line}\n`)
+		});
+	} catch (err) {
+		fail(err.message);
+	}
+}
+/**
+* An empty working-tree review usually means the work was committed, not that
+* there is no work: point at the branch's commits when there are any. The one
+* moment the flag is needed is the one moment the default mode shows nothing.
+*/
+function printBaseHint(spec, files) {
+	if (spec.kind !== "working-tree" || files !== 0) return;
+	const hint = suggestedBase(repoPath);
+	if (!hint) return;
+	console.log(`this branch has ${hint.commits} ${hint.commits === 1 ? "commit" : "commits"} since ${hint.base} — review them with \`diffo --base ${hint.base}\``);
+}
+async function fetchChangesetInfo(port) {
+	try {
+		return await (await fetch(apiUrl(port, "/api/changeset"), { signal: AbortSignal.timeout(2e3) })).json();
+	} catch {
+		return null;
+	}
+}
+async function fetchReviewState(port) {
+	try {
+		const res = await fetch(apiUrl(port, "/api/review"), { signal: AbortSignal.timeout(2e3) });
+		if (!res.ok) return null;
+		return await res.json();
+	} catch {
+		return null;
+	}
+}
+/**
+* The guide: an agent comment on the whole changeset. One per review by
+* convention, so the newest wins if an agent ever posted two. Resolved ones
+* still count — the reviewer resolving a guide means they are done with it, and
+* re-asking for one would only get the review a second guide.
+*
+* A landed review's guide doesn't count at all: it describes a changeset that
+* was committed away, so the next changeset deserves a fresh one — inheriting
+* it would orient the reviewer to work that is already behind them.
+*/
+function findGuideThread(review) {
+	if (review.landed) return void 0;
+	return review.threads.filter((t) => t.anchor.kind === "changeset" && t.messages[0]?.author === "agent").at(-1);
+}
+/** Two lines of repo + changeset context. A courtesy: any failure prints nothing. */
+async function printChangesetSummary(port) {
+	const info = await fetchChangesetInfo(port);
+	if (!info) return;
+	const { spec, stats, repo } = info;
+	console.log(`diffo · ${repo.name}${repo.branch ? ` (${repo.branch})` : ""}`);
+	console.log(stats.files === 0 ? `watching ${specLabel(spec)} · working tree is clean — nothing to review yet` : `watching ${specLabel(spec)} · ${stats.files} ${stats.files === 1 ? "file" : "files"} · +${stats.additions} −${stats.deletions}`);
+	printBaseHint(spec, stats.files);
+}
+/**
+* An explicit `--base` against a server watching something else deserves the
+* truth: the server keeps its spec (switching would move the diff under the
+* reviewer), so say what it IS watching and how to switch.
+*/
+async function warnSpecMismatch(port, asked) {
+	if (asked.kind !== "branch") return;
+	const info = await fetchChangesetInfo(port);
+	if (!info) return;
+	const watching = info.spec;
+	if (watching.kind === "branch" && watching.base === asked.base) return;
+	process.stderr.write(`diffo: this server is watching ${specLabel(watching)}, not vs ${asked.base} — run \`diffo stop\`, then re-run with --base to switch\n`);
+}
+function readStdin() {
+	return new Promise((resolvePromise, reject) => {
+		let data = "";
+		process.stdin.setEncoding("utf-8");
+		process.stdin.on("data", (chunk) => data += chunk);
+		process.stdin.on("end", () => resolvePromise(data));
+		process.stdin.on("error", reject);
+	});
+}
+/**
+* Every verb except `poll` — a short request/response against a loopback server,
+* so anything past ten seconds is a wedge, not slowness. Without the deadline a
+* server that goes quiet held the verb for undici's 300s default, long past the
+* point an agent harness gives up, so a `reply` could vanish with no error.
+*/
+const POST_TIMEOUT_MS = 1e4;
+async function postJson(port, path, body) {
+	let res;
+	try {
+		res = await fetch(apiUrl(port, path), {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...sessionHeaders()
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(POST_TIMEOUT_MS)
+		});
+	} catch {
+		fail("lost connection to the diffo server — re-run the command");
+	}
+	return {
+		status: res.status,
+		body: await res.json().catch(() => null)
+	};
+}
+if (command.kind === "status") {
+	const db = new DiffoDb();
+	let record;
+	try {
+		record = db.getServer(repoPath);
+	} finally {
+		db.close();
+	}
+	const health = record ? await fetchHealth(record.port) : null;
+	const verdict = record ? assessRunningServer(health, repoPath, VERSION) : "foreign";
+	if (!record || verdict === "foreign") {
+		if (command.json) console.log(JSON.stringify({ running: false }));
+		else console.log(record ? "no diffo server is watching this repo (its last registration is stale)" : "no diffo server is watching this repo");
+		process.exit(1);
+	}
+	const pid = health?.pid ?? record.pid;
+	const url = reviewUrl(record.port);
+	if (command.json) {
+		console.log(JSON.stringify({
+			running: true,
+			port: record.port,
+			pid: pid || null,
+			version: health?.version ?? null,
+			url
+		}));
+		process.exit(0);
+	}
+	await printChangesetSummary(record.port);
+	console.log(`server: port ${record.port}${pid ? ` · pid ${pid}` : ""} · v${health?.version ?? "pre-handshake"}` + (verdict === "replace" ? ` (this CLI is v${VERSION} — the next \`diffo\` replaces it)` : ""));
+	console.log(`→ ${url}`);
+	process.exit(0);
+}
+if (command.kind === "stop") {
+	const db = new DiffoDb();
+	try {
+		const record = db.getServer(repoPath);
+		if (!record) {
+			console.log("no diffo server is watching this repo — nothing to stop");
+			process.exit(0);
+		}
+		const health = await fetchHealth(record.port);
+		if (assessRunningServer(health, repoPath, VERSION) === "foreign") {
+			db.removeServer(repoPath, record.port);
+			console.log("no diffo server is watching this repo — cleared a stale registration");
+			process.exit(0);
+		}
+		if (!await retireServer(record.port, record.pid ?? null, health?.pid ?? null)) fail(`the server on port ${record.port}` + (record.pid ? ` (pid ${record.pid})` : "") + ` would not stop — kill it yourself, then re-run \`diffo stop\``);
+		db.removeServer(repoPath, record.port);
+		console.log(`stopped the diffo server on port ${record.port}`);
+	} finally {
+		db.close();
+	}
+	process.exit(0);
+}
+if (command.kind === "poll") {
+	const port = await requireServer();
+	process.stderr.write("diffo: waiting for the reviewer — keep this process attended: a tracked\nbackground task or the foreground, never detached.\nIf it is killed or times out, just re-run it: what the reviewer sent is\nheld in the review, so it outlives this poll and the server both.\n");
+	try {
+		const res = await fetch(apiUrl(port, "/api/agent/poll"), { headers: sessionHeaders() });
+		if (!res.ok) fail(`poll failed (${res.status})`);
+		const tookOverFrom = res.headers.get("x-diffo-took-over-from");
+		if (tookOverFrom) {
+			process.stderr.write(`diffo: another agent session (pid ${tookOverFrom}) was connected to this review —\nthis poll has taken it over, and that session has been told. Mention this to the\nuser: their feedback now comes here.\n`);
+			const review = await fetchReviewState(port);
+			const guide = review ? findGuideThread(review) : void 0;
+			if (guide) process.stderr.write(guideInherit(guide.id));
+		}
+		console.log((await res.text()).trim());
+	} catch {
+		fail("lost connection to the diffo server — re-run `poll` to keep listening");
+	}
+	process.exit(0);
+}
+if (command.kind === "reply") {
+	if (command.message === null && process.stdin.isTTY) fail("reply needs a message — pass --message \"<text>\" or pipe it on stdin");
+	const message = (command.message ?? await readStdin()).trim();
+	if (!message) fail("reply needs a message — pass --message \"<text>\" or pipe it on stdin");
+	const { status, body } = await postJson(await requireServer(), `/api/review/threads/${encodeURIComponent(command.threadId)}/messages`, {
+		author: "agent",
+		text: message
+	});
+	if (status === 404) fail(`no thread with id '${command.threadId}'`);
+	if (status !== 200) fail(`reply failed (${status})`);
+	const thread = body.thread;
+	console.log(JSON.stringify({
+		ok: true,
+		threadId: thread.id,
+		state: thread.state,
+		next_step: ACK_NEXT_STEP.reply
+	}));
+	process.exit(0);
+}
+if (command.kind === "comment") {
+	if (command.message === null && process.stdin.isTTY) fail("comment needs a message — pass --message \"<text>\" or pipe it on stdin");
+	const message = (command.message ?? await readStdin()).trim();
+	if (!message) fail("comment needs a message — pass --message \"<text>\" or pipe it on stdin");
+	const { status, body } = await postJson(await requireServer(), "/api/review/threads", {
+		author: "agent",
+		file: command.file,
+		line: command.line,
+		text: message
+	});
+	if (status !== 200) fail(`comment failed (${status})`);
+	console.log(JSON.stringify({
+		ok: true,
+		threadId: body.id,
+		next_step: ACK_NEXT_STEP.comment
+	}));
+	process.exit(0);
+}
+if (command.kind === "end") {
+	const { status, body } = await postJson(await requireServer(), "/api/agent/end", {});
+	if (status !== 200) fail(`end failed (${status})`);
+	const result = body;
+	console.log(JSON.stringify(result?.ok === false ? {
+		...result,
+		next_step: "nothing to do — you were not the attached agent"
+	} : {
+		ok: true,
+		next_step: ACK_NEXT_STEP.end
+	}));
+	process.exit(0);
+}
+if (!process.env.DIFFO_DAEMON) {
+	const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+	for (const target of refreshInstalledSkills({
+		packageRoot,
+		homeDir: homedir()
+	})) process.stderr.write(`diffo: refreshed the installed skill (${target})\n`);
+}
+/** Agents read piped stdout; a human's terminal never shows these lines. */
+async function printAgentNextStep(port) {
+	if (process.stdout.isTTY) return;
+	const review = await fetchReviewState(port);
+	const nudge = review ? guideNudge(findGuideThread(review) !== void 0) : null;
+	if (nudge) console.log(`first: ${nudge}`);
+	console.log("next: run `diffo poll` to receive the reviewer's feedback (`diffo help agent` prints the whole loop)");
+}
+const existing = await discoverServer();
+const takeOverPort = existing !== null && command.foreground && command.port !== void 0 && command.port !== existing.port ? command.port : null;
+if (existing !== null && takeOverPort === null) {
+	const url = reviewUrl(existing.port);
+	console.log(`diffo is already watching this repo`);
+	await warnSpecMismatch(existing.port, command.spec);
+	console.log(`→ ${url}`);
+	await printAgentNextStep(existing.port);
+	process.exit(0);
+}
+if (existing !== null && takeOverPort !== null) {
+	try {
+		await probePort(takeOverPort);
+	} catch (err) {
+		const code = err.code;
+		fail(code === "EADDRINUSE" ? `port ${takeOverPort} is already in use, so there is nothing to take over to — the server on port ${existing.port} is untouched and still watching this repo` : `cannot listen on port ${takeOverPort} (${code ?? err.message})`);
+	}
+	console.error(`diffo: taking this repo over from the server on port ${existing.port}`);
+	if (!await retireServer(existing.port, existing.pid, existing.pid)) fail(`the server on port ${existing.port} would not step aside — stop it, then re-run`);
+	const db = new DiffoDb();
+	db.removeServer(repoPath, existing.port);
+	db.close();
+}
+if (!command.foreground) {
+	const daemonPort = await requireServer(command.port, command.spec.kind === "branch" ? command.spec.base : void 0);
+	const url = reviewUrl(daemonPort);
+	await printChangesetSummary(daemonPort);
+	console.log(`→ ${url}`);
+	await printAgentNextStep(daemonPort);
+	if (command.open) openBrowser(url);
+	process.exit(0);
+}
+let port;
+try {
+	port = command.port === void 0 ? await preferredPort() : await probePort(command.port);
+} catch (err) {
+	const code = err.code;
+	if (command.port === void 0) fail(`no free port available (${code ?? err.message})`);
+	fail(code === "EADDRINUSE" ? `port ${command.port} is already in use — omit --port to take any free one` : `cannot listen on port ${command.port} (${code ?? err.message})`);
+}
+const here = dirname(fileURLToPath(import.meta.url));
+const clientDir = [resolve(here, "client"), resolve(here, "../dist/client")].find(existsSync) ?? resolve(here, "client");
+let started;
+try {
+	started = startServer({
+		port,
+		clientDir,
+		root,
+		spec: command.spec
+	});
+} catch (err) {
+	if (err instanceof MissingBaseError) {
+		console.error(`diffo: base branch '${err.base}' doesn't exist in this repo`);
+		process.exit(1);
+	}
+	if (err instanceof RepoAlreadyServedError) {
+		console.log(`diffo is already watching this repo`);
+		console.log(`→ ${reviewUrl(err.holder.port)}`);
+		process.exit(0);
+	}
+	throw err;
+}
+const { stats, repo } = started.store.get();
+const url = reviewUrl(port);
+const label = specLabel(command.spec);
+console.log(`diffo · ${repo.name}${repo.branch ? ` (${repo.branch})` : ""}`);
+if (stats.files === 0) console.log(`watching ${label} · working tree is clean — nothing to review yet`);
+else console.log(`watching ${label} · ${stats.files} ${stats.files === 1 ? "file" : "files"} · +${stats.additions} −${stats.deletions}`);
+printBaseHint(command.spec, stats.files);
+console.log(`→ ${url}`);
+if (command.open) openBrowser(url);
+process.on("SIGINT", () => {
+	process.exit(0);
+});
+process.on("SIGTERM", () => {
+	process.exit(0);
+});
+//#endregion
+export {};