@diffohq/diffo 0.0.2 → 0.2.0

package/dist/cli.mjs

@@ -1,17 +1,17 @@
 #!/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 { chmodSync, closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, 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 { createHash, randomUUID } from "node:crypto";
 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
@@ -94,11 +94,6 @@ function untouchedAgentVoice(thread) {
 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: []
@@ -128,26 +123,59 @@ function threadsInChangeset(files, threads) {
 		past
 	};
 }
+/** The line part of a hunk anchor's label: `12`, or `12-20` for a range. */
+function anchorSpan(anchor) {
+	return anchor.endLine === void 0 ? `${anchor.line}` : `${anchor.line}-${anchor.endLine}`;
+}
 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)`;
+	return `${anchor.path}:${anchorSpan(anchor)} (${anchor.side} side)`;
 }
 //#endregion
 //#region src/server/prompt.ts
-function snapshotHunk(changeset, hunkId) {
+/** A comment can anchor to a long range; the frozen text keeps its head. */
+const ANCHORED_TEXT_CAP = 10;
+function findHunk(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");
+		if (hunk) return hunk;
 	}
 	return null;
 }
+/**
+* Freeze what a new thread anchors to: the whole hunk as a diff snapshot, plus
+* — for the anchored line range — where those rows sit in it and their text.
+* Null for non-hunk anchors and for a hunk the changeset no longer has.
+*/
+function captureAnchor(changeset, anchor) {
+	if (anchor.kind !== "hunk") return null;
+	const hunk = findHunk(changeset, anchor.hunkId);
+	if (!hunk) return null;
+	const marker = {
+		add: "+",
+		del: "-",
+		context: " "
+	};
+	const rows = hunk.lines.map((l) => marker[l.kind] + l.text);
+	const codeContext = rows.join("\n");
+	const last = anchor.endLine ?? anchor.line;
+	const covered = hunk.lines.map((l, row) => ({
+		no: anchor.side === "old" ? l.oldNo : l.newNo,
+		row
+	})).filter((r) => r.no !== null && r.no >= anchor.line && r.no <= last);
+	if (covered.length === 0) return { codeContext };
+	const start = covered[0].row;
+	const end = covered.at(-1).row;
+	return {
+		codeContext,
+		anchored: {
+			start,
+			end,
+			text: rows.slice(start, Math.min(end + 1, start + ANCHORED_TEXT_CAP)).join("\n")
+		}
+	};
+}
 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(/\/$/, "");
@@ -191,11 +219,13 @@ const INSTALL_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 === "cleared") return `Post the guide if this changeset warrants one, then run \`${CLI_COMMANDS.poll}\` again to keep listening (${POLL_STANCE}).`;
 	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}).`,
+	replyMore: "Interim reply posted — the reviewer still sees you working on this thread. Post the follow-up as a plain reply (no --more) BEFORE your next poll: re-polling closes the batch and counts the promise as never kept.",
 	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."
 };
@@ -242,6 +272,11 @@ const INTENT_CONTRACT = {
 	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 agent spoke last: the thread is answered until the reviewer says more.
+* A reply that promised a follow-up (`--more`) is not an answer yet. */
+function answeredByAgent(thread) {
+	return thread.messages.at(-1)?.author === "agent" && thread.awaitingFollowUp !== true;
+}
 /** 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.";
@@ -252,9 +287,34 @@ function intentContract(threads) {
 	if (threads.some((t) => t.closingNote)) lines.push(CLOSING_CONTRACT);
 	return lines;
 }
-function replyProtocol(threads) {
+/**
+* The short form, for a session that already received the full protocol this
+* attachment (tracked per session pid by the DeliveryQueue). The full text is
+* ~580 tokens and re-shipping it with every delivery was the loop's largest
+* recurring cost; the compact form keeps only the per-batch contract — intent
+* rules, the reply command, the re-poll — plus the pointer that reprints the rest.
+*/
+function compactProtocol(threads) {
+	return `## How to respond
+
+Same protocol as your earlier deliveries (\`${CLI} help agent\` reprints it in full):
+
+1. Act on each thread.
+${intentContract(threads).map((line) => `   ${line}`).join("\n")}
+2. Reply per thread as soon as it is handled — what changed and where (\`file:line\`), verify it the cheapest honest way first:
+
+   ${CLI_COMMANDS.reply}
+
+3. When every thread is handled, run \`${CLI_COMMANDS.poll}\` again to keep listening.
+
+Change only what these threads ask about — the reviewer is mid-read. Re-read
+the current file before editing; the code may have moved. Resolving a thread
+is the reviewer's call, never yours.`;
+}
+function replyProtocol(threads, mode = "full") {
+	if (mode === "compact") return compactProtocol(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."] : [];
+	const answeredNote = threads.some((t) => answeredByAgent(t)) ? ["   - 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.
@@ -274,6 +334,10 @@ ${[...intentContract(threads).map((line) => `   ${line}`), ...answeredNote].join
    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.
+   A reply that only promises a follow-up ("I'll investigate and report
+   back") is not an answer — post it with \`--more\` so the reviewer keeps
+   seeing you at work on that thread, then post the real answer as a plain
+   reply (no \`--more\`) before your next poll.
    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
@@ -341,20 +405,84 @@ function siblingLines(siblings) {
 	].join("\n");
 }
 const SNAPSHOT_LINE_CAP = 25;
+/** The heading's movement-proof identifier: the first anchored line's text,
+* stripped of its diff marker. The line numbers in `describeAnchor` go stale
+* the moment the code moves; this text is what the agent can still search for. */
+function anchorQuote(thread) {
+	const first = thread.anchored?.text.split("\n").map((line) => line.slice(1).trim()).find((line) => line !== "")?.slice(0, 80);
+	if (!first) return "";
+	return thread.anchor.kind === "hunk" && thread.anchor.endLine !== void 0 ? ` — starts at: "${first}"` : ` — "${first}"`;
+}
+/** When `path:line` must not be trusted against the working tree: an old-side
+* anchor never matches it, and a rotated hunk means the code moved under the
+* numbers. At most one note — removed code can't also have "moved". */
+function anchorNote(thread) {
+	if (thread.anchor.kind !== "hunk") return [];
+	if (thread.anchor.side === "old") return ["This comments on removed code — the anchored lines are the old version, not the current file."];
+	if (thread.codeChanged) return ["The code under this comment changed after the comment was written — its line numbers are stale. Find the code by its anchored lines, not by number."];
+	return [];
+}
+/** The `[from, to)` slice of the snapshot to show: the anchored rows centered
+* inside the cap. A range longer than the cap keeps its head. */
+function snapshotWindow(total, anchored) {
+	const size = Math.min(total, SNAPSHOT_LINE_CAP);
+	const span = anchored.end - anchored.start + 1;
+	const pad = Math.floor(Math.max(0, size - span) / 2);
+	const from = Math.min(Math.max(0, anchored.start - pad), total - size);
+	return {
+		from,
+		to: from + size
+	};
+}
+/** The snapshot as the agent sees it: windowed on the anchored rows, each of
+* them marked with `>`. Threads from before `anchored` existed keep the old
+* head-of-hunk window. */
+function snapshotBlock(thread) {
+	const { codeContext, anchored } = thread;
+	if (!codeContext) {
+		if (!anchored) return [];
+		const shown = anchored.text.split("\n");
+		const cut = anchored.end - anchored.start + 1 - shown.length;
+		return [
+			"The commented lines, as they were when the comment was written:",
+			"```diff",
+			...shown,
+			"```",
+			...cut > 0 ? [`(… and ${cut} more commented lines)`] : []
+		];
+	}
+	const lines = codeContext.split("\n");
+	const where = thread.anchor.kind === "changeset" ? "the file" : `\`${thread.anchor.path}\``;
+	if (thread.deliveredThrough) return [`(diff snapshot delivered to you earlier — read the current ${where} instead)`];
+	if (!anchored) return [
+		"The commented change:",
+		"```diff",
+		...lines.slice(0, SNAPSHOT_LINE_CAP),
+		"```",
+		...lines.length > SNAPSHOT_LINE_CAP ? [`(… and ${lines.length - SNAPSHOT_LINE_CAP} more snapshot lines — read the current ${where} instead)`] : []
+	];
+	const { from, to } = snapshotWindow(lines.length, anchored);
+	const shown = lines.slice(from, to).map((line, i) => from + i >= anchored.start && from + i <= anchored.end ? `>${line}` : line);
+	const cut = lines.length - (to - from);
+	return [
+		"The commented change (`>` marks the commented lines):",
+		"```diff",
+		...shown,
+		"```",
+		...cut > 0 ? [`(windowed to the commented lines — ${cut} more snapshot lines around them; read the current ${where} for the full change)`] : []
+	];
+}
 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");
+	return [
+		`### Thread ${index + 1}${label} — ${describeAnchor(thread.anchor)}${anchorQuote(thread)}${again}`,
+		`id: ${thread.id}`,
+		...anchorNote(thread),
+		...snapshotBlock(thread),
+		"Messages:",
+		...thread.messages.map((m) => `- ${m.author}: ${m.text.replace(/\n/g, "\n  ")}`)
+	].join("\n");
 }
 function buildThreadPrompt(thread, ctx) {
 	const siblings = siblingLines(ctx.siblings ?? []);
@@ -365,7 +493,7 @@ function buildThreadPrompt(thread, ctx) {
 		threadBlock(thread, 0),
 		"",
 		...siblings ? [siblings, ""] : [],
-		replyProtocol([thread]),
+		replyProtocol([thread], ctx.protocol),
 		""
 	].join("\n");
 }
@@ -377,7 +505,24 @@ function buildCoalescedPrompt(threads, ctx) {
 		...ctx.changeset ? [specLine(ctx.changeset), ""] : [],
 		...threads.map((t, i) => `${threadBlock(t, i)}\n`),
 		...siblings ? [siblings, ""] : [],
-		replyProtocol(threads),
+		replyProtocol(threads, ctx.protocol),
+		""
+	].join("\n");
+}
+/**
+* The reviewer started the review over — the previous round landed, and its
+* threads and guide were cleared. Nothing to act on; the one thing owed is
+* orientation for the fresh round, so this restates the guide doctrine the way
+* the open-time nudge does (payloads must stand alone — see POLL_STANCE).
+*/
+function buildClearedPrompt(ctx) {
+	return [
+		`The reviewer cleared the review in \`${ctx.repo.name}\` (branch \`${ctx.repo.branch}\`): the previous round landed, and its threads and guide are gone. What the reviewer sees now is a fresh round.`,
+		"",
+		...ctx.changeset ? [specLine(ctx.changeset), ""] : [],
+		`There is no feedback to act on. But the fresh round has no guide — if this changeset needs one (${GUIDE.when}): post it — one comment on the whole changeset: ${GUIDE.what}: \`${CLI_COMMANDS.guide}\` (no file, so it anchors to the changeset). ${GUIDE.stance}.`,
+		"",
+		`Then run \`${CLI_COMMANDS.poll}\` again to keep listening (${POLL_STANCE}).`,
 		""
 	].join("\n");
 }
@@ -385,7 +530,9 @@ 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 ordered = closing ? [closing, ...sent.filter((t) => t !== closing)] : sent;
+	const answered = ordered.filter((t) => t !== closing && answeredByAgent(t));
+	const actionable = ordered.filter((t) => !answered.includes(t));
 	const changed = coverage.changedFiles ?? [];
 	const commented = coverage.commentedUnread ?? [];
 	const filtered = coverage.filteredOut ?? [];
@@ -396,7 +543,6 @@ function buildFinishPrompt(threads, ctx, coverage) {
 		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 ? [
@@ -409,16 +555,18 @@ function buildFinishPrompt(threads, ctx, coverage) {
 	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 (answered.length > 0) parts.push(`${answered.length} thread${answered.length === 1 ? "" : "s"} you already answered, with nothing new since — no reply owed, not repeated here:`, ...answered.map((t) => `- ${t.id} — ${describeAnchor(t.anchor)}`), "");
 	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), "");
+	if (actionable.length === 0) {
+		const fullRead = coverage.totalHunks > 0 && coverage.viewedHunks >= coverage.totalHunks && changed.length === 0 && commented.length === 0 && filtered.length === 0 && coverage.skippedFiles.length === 0;
+		parts.push(fullRead && coverage.note === void 0 ? "They read everything and left nothing to address — take it as a green light to proceed." : "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, ctx.protocol), "");
 	return parts.join("\n");
 }
 //#endregion
@@ -481,11 +629,15 @@ The loop:
    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}.
+   Attached without ever seeing the URL (a takeover, a fresh session)?
+   \`diffo status\` prints it.
+2. Guide — post one only when the changeset needs orientation:
+   ${GUIDE.when}.
+   Before sharing the URL, post ONE comment on the whole changeset
+   (\`diffo comment -m "…"\`, no file), containing:
+   ${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}.
@@ -495,7 +647,10 @@ The loop:
    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.
+   \`\`\`mermaid fence draws a diagram. A reply that only promises a
+   follow-up ("I'll investigate and report back") goes out with \`--more\` —
+   the reviewer keeps seeing you at work — and the real answer follows as a
+   plain reply before the next poll.
 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
@@ -506,7 +661,9 @@ 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.
+  re-poll to take it back from another session — tell the user instead. When
+  a poll says it took the review over, or returns status "superseded", say so
+  to the user: their feedback moved with it.
 - Resolving a thread is the reviewer's call, never yours.`,
 	poll: `diffo poll — wait for the reviewer's feedback
 
@@ -531,6 +688,10 @@ Usage: diffo reply <threadId> --message "<text>"
 
 Thread ids arrive in poll payloads. Each run posts one message, so don't
 re-run a reply that succeeded.
+--more marks the reply as interim: you are still working, and a follow-up
+reply on this thread is promised. The reviewer keeps seeing the thread as
+"with the agent" until your next plain reply; going quiet instead marks it
+unanswered.
 Messages render GitHub-flavored markdown; a \`\`\`mermaid fence renders as a
 diagram in the review.
 
@@ -769,6 +930,7 @@ function parseVerb(verb, rest) {
 				short: "m"
 			},
 			line: { type: "string" },
+			more: { type: "boolean" },
 			json: { type: "boolean" },
 			help: {
 				type: "boolean",
@@ -789,6 +951,10 @@ function parseVerb(verb, rest) {
 		kind: "error",
 		message: `'${verb}' takes no --json`
 	};
+	if (values.more && verb !== "reply") return {
+		kind: "error",
+		message: `'${verb}' takes no --more`
+	};
 	if (verb === "poll" || verb === "end" || verb === "setup" || verb === "status" || verb === "stop") {
 		if (positionals.length > 0) return {
 			kind: "error",
@@ -821,7 +987,8 @@ function parseVerb(verb, rest) {
 		return {
 			kind: "reply",
 			threadId,
-			message: values.message ?? null
+			message: values.message ?? null,
+			more: values.more === true
 		};
 	}
 	const file = positionals[0] ?? null;
@@ -849,6 +1016,57 @@ function parseVerb(verb, rest) {
 	};
 }
 //#endregion
+//#region src/devStamp.ts
+/**
+* A fingerprint of the dev checkout's source. The dev CLI runs `src/` straight
+* through tsx, so "which build is this?" isn't answered by the package version —
+* every edit is a new build with the same version string. The stamp is what
+* changes instead: the server reports the stamp of the source it loaded, the
+* next `diffo` open compares it to the source on disk, and a mismatch retires
+* the server exactly like a version bump would.
+*
+* Tests are skipped — they never run inside the server — and `index.html` is
+* included because the client bundle is built from it.
+*/
+function computeSrcStamp(checkoutRoot) {
+	const hash = createHash("sha256");
+	const file = (path, name) => {
+		hash.update(name);
+		hash.update("\0");
+		hash.update(readFileSync(path));
+		hash.update("\0");
+	};
+	const walk = (dir, prefix) => {
+		const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+		for (const entry of entries) {
+			if (entry.name.endsWith(".test.ts") || entry.name.endsWith(".test.tsx")) continue;
+			const path = join(dir, entry.name);
+			const name = `${prefix}${entry.name}`;
+			if (entry.isDirectory()) walk(path, `${name}/`);
+			else if (entry.isFile()) file(path, name);
+		}
+	};
+	walk(join(checkoutRoot, "src"), "src/");
+	try {
+		file(join(checkoutRoot, "index.html"), "index.html");
+	} catch {}
+	return hash.digest("hex").slice(0, 16);
+}
+/**
+* This process's stamp, captured at import — for the server that means the
+* source it actually loaded, not whatever is on disk by the time someone asks.
+* Null outside dev (a published build has no `src/` to stamp, and its version
+* string already does this job).
+*/
+const SRC_STAMP = (() => {
+	if (!IS_DEV) return null;
+	try {
+		return computeSrcStamp(CHECKOUT_ROOT);
+	} catch {
+		return null;
+	}
+})();
+//#endregion
 //#region src/server/git.ts
 const MAX_BUFFER = 52428800;
 const SNIFF_BYTES = 8192;
@@ -1371,7 +1589,8 @@ var DiffoDb = class {
 			const known = /* @__PURE__ */ new Set([
 				"reviews",
 				"servers",
-				"repo_ports"
+				"repo_ports",
+				"ui_settings"
 			]);
 			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("\"", "\"\"")}"`);
@@ -1396,6 +1615,10 @@ var DiffoDb = class {
         repo_path TEXT PRIMARY KEY,
         port      INTEGER NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS ui_settings (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
       PRAGMA user_version = ${SCHEMA_VERSION};
     `);
 		this.pruneVanishedRepos();
@@ -1471,6 +1694,16 @@ var DiffoDb = class {
 		this.db.prepare(`INSERT INTO repo_ports (repo_path, port) VALUES (?, ?)
          ON CONFLICT(repo_path) DO UPDATE SET port = excluded.port`).run(repoPath, port);
 	}
+	/** Reviewer preferences that must outlive one server's origin — every repo is
+	* served from its own port, so localStorage alone can't hold a choice like
+	* the theme. Keyed blobs, no scope: these are per-human, not per-repo. */
+	getUiSetting(key) {
+		return this.db.prepare("SELECT value FROM ui_settings WHERE key = ?").get(key)?.value ?? null;
+	}
+	setUiSetting(key, value) {
+		this.db.prepare(`INSERT INTO ui_settings (key, value) VALUES (?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(key, value);
+	}
 	getServer(repoPath) {
 		const row = this.db.prepare("SELECT port, pid, started_at FROM servers WHERE repo_path = ?").get(repoPath);
 		return row ? {
@@ -1507,7 +1740,7 @@ const VERSION = (() => {
 		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;
+			if (pkg.name === "@diffohq/diffo" && typeof pkg.version === "string") return pkg.version;
 		} catch {}
 	}
 	return "0.0.0";
@@ -1550,6 +1783,11 @@ var DeliveryQueue = class DeliveryQueue {
 		reason: "no-agent"
 	};
 	owner = null;
+	/** The session pid that last received the full reply protocol. Later
+	* deliveries to the same session carry the compact form — the full text is
+	* the loop's largest recurring token cost. A takeover (new pid) or an
+	* anonymous session (null pid) always gets the full form again. */
+	protocolPid = null;
 	batch = null;
 	batchWatch = null;
 	waiterWatch = null;
@@ -1610,6 +1848,12 @@ var DeliveryQueue = class DeliveryQueue {
 	ownerPid() {
 		return this.ownerConnected() ? this.owner : null;
 	}
+	needsFullProtocol() {
+		return this.owner === null || this.owner !== this.protocolPid;
+	}
+	markProtocolSent() {
+		this.protocolPid = this.owner;
+	}
 	/**
 	* 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
@@ -1635,7 +1879,8 @@ var DeliveryQueue = class DeliveryQueue {
 		if (!bucket) {
 			bucket = {
 				threads: /* @__PURE__ */ new Set(),
-				finish: null
+				finish: null,
+				cleared: false
 			};
 			this.buckets.set(this.scope, bucket);
 		}
@@ -1764,6 +2009,14 @@ var DeliveryQueue = class DeliveryQueue {
 		this.bucket().finish = coverage;
 		this.wake();
 	}
+	/** The reviewer cleared the review. A boolean, not a queue: clearing twice
+	* before a poll still owes exactly one heads-up. */
+	enqueueCleared() {
+		this.bucket().cleared = true;
+		const queued = this.waiter === null;
+		this.wake();
+		if (queued) this.notify();
+	}
 	drop(threadId) {
 		for (const bucket of this.buckets.values()) bucket.threads.delete(threadId);
 		this.deliveredAt.delete(threadId);
@@ -1823,7 +2076,7 @@ var DeliveryQueue = class DeliveryQueue {
 	}
 	hasPending() {
 		const bucket = this.buckets.get(this.scope);
-		return bucket !== void 0 && (bucket.threads.size > 0 || bucket.finish !== null);
+		return bucket !== void 0 && (bucket.threads.size > 0 || bucket.finish !== null || bucket.cleared);
 	}
 	wake() {
 		if (this.waiter === null) return;
@@ -1845,11 +2098,19 @@ var DeliveryQueue = class DeliveryQueue {
 			kind: "threads",
 			threadIds: [...bucket.threads]
 		};
+		if (bucket.cleared) return { kind: "cleared" };
 		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) {
+		if (snapshot.kind === "cleared") {
+			const bucket = this.buckets.get(this.scope);
+			if (bucket) bucket.cleared = false;
+			this.armGrace();
+			this.notify();
+			return;
+		}
 		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);
@@ -1868,10 +2129,19 @@ var DeliveryQueue = class DeliveryQueue {
 		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) {
+	* was delivered, or null when the reply wasn't an answer to a delivery.
+	* `interim` (a `--more` reply) keeps the thread on the clock: a follow-up is
+	* still owed, so the spinner stays and a batch that closes without the
+	* follow-up counts the thread unanswered. */
+	agentReplied(threadId, interim = false) {
 		const at = this.deliveredAt.get(threadId);
-		this.deliveredAt.delete(threadId);
+		if (!interim) this.deliveredAt.delete(threadId);
+		else if (at === void 0 && this.batch) {
+			this.deliveredAt.set(threadId, Date.now());
+			if (!this.batch.threadIds.includes(threadId)) this.batch.threadIds.push(threadId);
+			this.awaitingReply = true;
+			this.clearGrace();
+		}
 		if (this.batch) this.batch.sawReply = true;
 		if (this.deliveredAt.size > 0) {
 			if (this.awaitingReply) {
@@ -1981,6 +2251,15 @@ var IdleMonitor = class {
 *   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.
+* - The commit can also go unwitnessed: it lands and the next round starts
+*   while no server watches, so no recompute ever sees the empty diff. The
+*   evidence survives anyway — HEAD advanced past `seenHead` AND every hunk
+*   the review pointed at (thread anchors, the last finish) is gone from the
+*   current changeset. Both together stamp even over a non-empty diff; either
+*   alone does not (an unrelated commit leaves the reviewed hunks in place, an
+*   agent rewriting every hunk between recomputes leaves HEAD at `seenHead`).
+*   A review that never anchored to a hunk has no such evidence and waits for
+*   the witnessed path.
 * - 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
@@ -1993,7 +2272,7 @@ var IdleMonitor = class {
 * 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) {
+function maintainLanded(review, hasFiles, currentHunkIds, git) {
 	const head = git.head();
 	if (head === null) return null;
 	const state = review.get();
@@ -2005,7 +2284,7 @@ function maintainLanded(review, hasFiles, git) {
 			outcome = "cleared";
 		}
 	}
-	if (!review.get().landed && !hasFiles && !reviewEmpty && state.seenHead !== void 0 && state.seenHead !== head && git.isAncestor(state.seenHead, head) === true) {
+	if (!review.get().landed && (!hasFiles || reviewedHunksAllLanded(state, currentHunkIds)) && !reviewEmpty && state.seenHead !== void 0 && state.seenHead !== head && git.isAncestor(state.seenHead, head) === true) {
 		review.markLanded({
 			sha: head,
 			subject: git.subject(head),
@@ -2016,6 +2295,18 @@ function maintainLanded(review, hasFiles, git) {
 	if (hasFiles || reviewEmpty) review.noteHead(head);
 	return outcome;
 }
+/** The unwitnessed-landing evidence: the review pointed at hunks, and none of
+* them survive in the current changeset. Vacuous truth deliberately fails —
+* a review of only file- and changeset-anchored threads names no hunks, so it
+* cannot testify that they landed. */
+function reviewedHunksAllLanded(state, currentHunkIds) {
+	const referenced = /* @__PURE__ */ new Set();
+	for (const thread of state.threads) if (thread.anchor.kind === "hunk") referenced.add(thread.anchor.hunkId);
+	for (const id of state.lastFinish?.hunkIds ?? []) referenced.add(id);
+	if (referenced.size === 0) return false;
+	for (const id of referenced) if (currentHunkIds.has(id)) return false;
+	return true;
+}
 //#endregion
 //#region src/server/review.ts
 const STATES = [
@@ -2068,14 +2359,15 @@ var ReviewStore = class {
 		this.listeners.add(listener);
 		return () => this.listeners.delete(listener);
 	}
-	createThread(anchor, text, codeContext, intent, author = "reviewer") {
+	createThread(anchor, text, capture, intent, author = "reviewer") {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		return this.insert({
 			id: randomUUID(),
 			anchor,
 			state: "open",
 			...intent ? { intent } : {},
-			codeContext,
+			codeContext: capture?.codeContext ?? null,
+			...capture?.anchored ? { anchored: capture.anchored } : {},
 			codeChanged: false,
 			messages: [{
 				id: randomUUID(),
@@ -2129,7 +2421,7 @@ var ReviewStore = class {
 	* 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) {
+	addMessage(threadId, author, text, withheld = false, seenThroughMs, followUp = false) {
 		return this.update(threadId, ({ unanswered: _answered, ...thread }) => {
 			const message = {
 				id: randomUUID(),
@@ -2137,9 +2429,11 @@ var ReviewStore = class {
 				text,
 				at: (/* @__PURE__ */ new Date()).toISOString()
 			};
-			const raced = author === "agent" && seenThroughMs !== void 0 ? thread.messages.findIndex((m) => Date.parse(m.at) > seenThroughMs) : -1;
+			const raced = author === "agent" && seenThroughMs !== void 0 ? thread.messages.findIndex((m) => m.author === "reviewer" && Date.parse(m.at) > seenThroughMs) : -1;
+			const { awaitingFollowUp: _promised, ...settled } = thread;
 			return {
-				...thread,
+				...author === "agent" ? settled : thread,
+				...author === "agent" && followUp ? { awaitingFollowUp: true } : {},
 				...withheld && author === "reviewer" ? { withheld: true } : {},
 				messages: raced === -1 ? [...thread.messages, message] : [
 					...thread.messages.slice(0, raced),
@@ -2188,7 +2482,7 @@ var ReviewStore = class {
 		const threads = this.state.threads.map((thread) => {
 			if (!wanted.has(thread.id) || !applies(thread)) return thread;
 			changed = true;
-			const { unanswered: _was, ...rest } = thread;
+			const { unanswered: _was, awaitingFollowUp: _promised, ...rest } = thread;
 			return thread.unanswered ? rest : {
 				...rest,
 				unanswered: true
@@ -2202,8 +2496,9 @@ var ReviewStore = class {
 		this.commit();
 	}
 	setState(threadId, state) {
-		return this.update(threadId, (thread) => ({
+		return this.update(threadId, ({ awaitingFollowUp: promised, ...thread }) => ({
 			...thread,
+			...promised && state !== "resolved" ? { awaitingFollowUp: true } : {},
 			state,
 			...state === "sent" && !thread.sentAt ? { sentAt: (/* @__PURE__ */ new Date()).toISOString() } : {},
 			...state === "resolved" ? { codeContext: null } : {}
@@ -2454,7 +2749,6 @@ function normalizeCoverage(value) {
 		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 } : {}
 	};
 }
@@ -2489,12 +2783,14 @@ function parseAnchor(value) {
 		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;
+		const endLine = typeof anchor.endLine === "number" && Number.isInteger(anchor.endLine) && anchor.endLine > anchor.line ? anchor.endLine : void 0;
 		return {
 			kind: "hunk",
 			hunkId: anchor.hunkId,
 			path: anchor.path,
 			side: anchor.side,
-			line: anchor.line
+			line: anchor.line,
+			...endLine !== void 0 ? { endLine } : {}
 		};
 	}
 	if (anchor.kind === "file") return typeof anchor.path === "string" ? {
@@ -2503,12 +2799,25 @@ function parseAnchor(value) {
 	} : null;
 	return anchor.kind === "changeset" ? { kind: "changeset" } : null;
 }
+/** Dropped when malformed — the thread is still fine without it. */
+function normalizeAnchored(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const a = value;
+	if (typeof a.start !== "number" || typeof a.end !== "number" || typeof a.text !== "string") return null;
+	if (!Number.isInteger(a.start) || !Number.isInteger(a.end) || a.start < 0 || a.end < a.start) return null;
+	return {
+		start: a.start,
+		end: a.end,
+		text: a.text
+	};
+}
 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;
+	const anchored = normalizeAnchored(t.anchored);
 	if (!Array.isArray(t.messages)) return null;
 	const messages = [];
 	for (const m of t.messages) {
@@ -2530,8 +2839,10 @@ function normalizeThread(value, now) {
 		state: t.state,
 		...THREAD_INTENTS.includes(t.intent) ? { intent: t.intent } : {},
 		codeContext: typeof t.codeContext === "string" ? t.codeContext : null,
+		...anchored ? { anchored } : {},
 		codeChanged: t.codeChanged === true,
 		...t.unanswered === true ? { unanswered: true } : {},
+		...t.awaitingFollowUp === true && t.unanswered !== true ? { awaitingFollowUp: true } : {},
 		...t.closingNote === true ? { closingNote: true } : {},
 		...typeof t.sentAt === "string" ? { sentAt: t.sentAt } : {},
 		messages,
@@ -3007,7 +3318,8 @@ function createApp(ctx, store, review, queue) {
 		repo: resolve(ctx.root),
 		app: "diffo",
 		version: VERSION,
-		pid: process.pid
+		pid: process.pid,
+		...SRC_STAMP === null ? {} : { srcStamp: SRC_STAMP }
 	}));
 	app.post("/api/shutdown", (c) => {
 		setImmediate(() => ctx.onShutdownRequest?.());
@@ -3016,6 +3328,22 @@ function createApp(ctx, store, review, queue) {
 			note: "shutting down"
 		});
 	});
+	const THEME_VALUES = /* @__PURE__ */ new Set([
+		"system",
+		"light",
+		"dark"
+	]);
+	app.get("/api/settings", (c) => {
+		const theme = ctx.uiSettings?.get("theme") ?? null;
+		return c.json({ theme: theme !== null && THEME_VALUES.has(theme) ? theme : null });
+	});
+	app.put("/api/settings", async (c) => {
+		if (!ctx.uiSettings) return c.json({ error: "settings unavailable" }, 503);
+		const theme = (await c.req.json().catch(() => null))?.theme;
+		if (typeof theme !== "string" || !THEME_VALUES.has(theme)) return c.json({ error: "need {theme: \"system\" | \"light\" | \"dark\"}" }, 400);
+		ctx.uiSettings.set("theme", theme);
+		return c.json({ ok: true });
+	});
 	const repoInfo = () => store?.get().repo ?? {
 		path: resolve(ctx.root),
 		name: "",
@@ -3065,14 +3393,14 @@ function createApp(ctx, store, review, queue) {
 			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 capture = store ? captureAnchor(store.get(), anchor) : null;
+			return c.json(review.createThread(anchor, text, capture, 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));
+		const capture = store ? captureAnchor(store.get(), anchor) : null;
+		return c.json(review.createThread(anchor, text, capture, intent));
 	});
 	app.post("/api/review/threads/:id/messages", async (c) => {
 		if (!review) return c.json({ error: "review unavailable" }, 503);
@@ -3083,9 +3411,10 @@ function createApp(ctx, store, review, queue) {
 			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 more = body?.more === true;
+			const waitedMs = queue?.agentReplied(id, more) ?? null;
 			const seenThroughMs = waitedMs === null ? void 0 : Date.now() - waitedMs;
-			const thread = review.addMessage(id, "agent", text, false, seenThroughMs);
+			const thread = review.addMessage(id, "agent", text, false, seenThroughMs, more);
 			if (!thread) return c.json({ error: "no such thread" }, 404);
 			if (waitedMs !== null) review.annotateAgentReplies([thread.id], waitedMs);
 			return c.json({
@@ -3117,8 +3446,11 @@ function createApp(ctx, store, review, queue) {
 	});
 	app.delete("/api/review/threads", (c) => {
 		if (!review) return c.json({ error: "review unavailable" }, 503);
+		const before = review.get();
+		const hadRound = before.threads.length > 0 || before.lastFinish !== void 0;
 		const removed = review.reset();
 		for (const id of removed) queue?.drop(id);
+		if (hadRound && (store?.get().files.length ?? 0) > 0) queue?.enqueueCleared();
 		return c.json({ removed: removed.length });
 	});
 	app.delete("/api/review/landed", (c) => {
@@ -3157,7 +3489,6 @@ function createApp(ctx, store, review, queue) {
 			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);
@@ -3170,7 +3501,6 @@ function createApp(ctx, store, review, queue) {
 			skippedFiles: fileList(src.skippedFiles) ?? [],
 			...changedFiles !== void 0 ? { changedFiles } : {},
 			...commentedUnread !== void 0 ? { commentedUnread } : {},
-			...verdict !== void 0 ? { verdict } : {},
 			...note !== void 0 ? { note } : {}
 		};
 	};
@@ -3263,20 +3593,37 @@ function createApp(ctx, store, review, queue) {
 	});
 	const pollPayload = (snapshot) => {
 		const threads = review?.get().threads ?? [];
+		const protocol = queue?.needsFullProtocol() === false ? "compact" : void 0;
+		if (snapshot.kind === "cleared") return {
+			status: "feedback",
+			kind: "cleared",
+			threadIds: [],
+			prompt: buildClearedPrompt({
+				repo: repoInfo(),
+				changeset: store?.get() ?? null
+			})
+		};
 		if (snapshot.kind === "finish") {
 			const batch = activeThreads(threads);
 			return {
 				status: "feedback",
 				kind: "finish",
-				threadIds: batch.filter((t) => t.state === "sent").map((t) => t.id),
+				threadIds: batch.filter((t) => t.state === "sent" && !answeredByAgent(t)).map((t) => t.id),
 				prompt: buildFinishPrompt(batch, {
 					repo: repoInfo(),
-					changeset: store?.get() ?? null
+					changeset: store?.get() ?? null,
+					protocol
 				}, 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));
+		const prompt = delivered.length === 1 ? buildThreadPrompt(delivered[0], {
+			...promptCtx(delivered[0].id),
+			protocol
+		}) : buildCoalescedPrompt(delivered, {
+			...promptCtx(...snapshot.threadIds),
+			protocol
+		});
 		return {
 			status: "feedback",
 			kind: "threads",
@@ -3354,6 +3701,7 @@ function createApp(ctx, store, review, queue) {
 					await s.write(JSON.stringify(payload));
 					if (aborted) return;
 					queue.confirm(snapshot, payload.threadIds);
+					if (payload.threadIds.length > 0) queue.markProtocolSent();
 					review.markDelivered(payload.threadIds);
 					review.clearUnanswered(payload.threadIds);
 					if (snapshot.kind === "finish") review.markFinishCollected();
@@ -3512,6 +3860,8 @@ function markDevIndex(html, isDev) {
 	return html.replace(/<title>[^<]*<\/title>/, "<title>diffo-dev</title>").replace(/<\/head>/, "    <meta name=\"diffo-env\" content=\"development\" />\n  </head>");
 }
 function rehydrateQueue(review, queue) {
+	const promised = review.get().threads.filter((t) => t.awaitingFollowUp === true).map((t) => t.id);
+	if (promised.length > 0) review.markUnanswered(promised);
 	const state = review.get();
 	queue.enqueueThreads(undeliveredThreadIds(state.threads));
 	const finish = state.lastFinish;
@@ -3549,8 +3899,8 @@ function startServer(options) {
 		isAncestor: (ancestor, descendant) => isAncestor(options.root, ancestor, descendant),
 		subject: (sha) => getCommitSubject(options.root, sha)
 	};
-	const checkLanded = (hasFiles) => {
-		if (maintainLanded(review, hasFiles, landedGit) === "stamped") {
+	const checkLanded = (hasFiles, hunkIds) => {
+		if (maintainLanded(review, hasFiles, hunkIds, landedGit) === "stamped") {
 			const landed = review.get().landed;
 			if (landed) log(`changeset landed in ${landed.sha.slice(0, 7)} — offering a fresh review`);
 		}
@@ -3561,11 +3911,13 @@ function startServer(options) {
 		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);
+		const hunkIds = new Set(changeset.files.flatMap((f) => f.hunks.map((h) => h.id)));
+		review.reconcile(hunkIds);
+		checkLanded(changeset.files.length > 0, hunkIds);
 	});
-	review.reconcile(new Set(store.get().files.flatMap((f) => f.hunks.map((h) => h.id))));
-	checkLanded(store.get().files.length > 0);
+	const startupHunkIds = new Set(store.get().files.flatMap((f) => f.hunks.map((h) => h.id)));
+	review.reconcile(startupHunkIds);
+	checkLanded(store.get().files.length > 0, startupHunkIds);
 	const idleTimeoutMs = resolveIdleTimeoutMs(process.env);
 	let idle;
 	if (idleTimeoutMs !== null) {
@@ -3581,7 +3933,11 @@ function startServer(options) {
 	const app = createApp({
 		...options,
 		idle,
-		onShutdownRequest: options.onShutdownRequest ?? (() => process.exit(0))
+		onShutdownRequest: options.onShutdownRequest ?? (() => process.exit(0)),
+		uiSettings: {
+			get: (key) => db.getUiSetting(key),
+			set: (key, value) => db.setUiSetting(key, value)
+		}
 	}, store, review, queue);
 	const server = serve({
 		fetch: app.fetch,
@@ -3635,9 +3991,17 @@ function reviewUrl(port) {
 //#endregion
 //#region src/serverLifecycle.ts
 const MAX_LOG_BYTES = 2097152;
-function assessRunningServer(health, repoPath, version) {
+/**
+* `srcStamp` is the dev-build refinement of the version check: a dev server's
+* version never changes across source edits, so an expected stamp (non-null)
+* makes a server started from other source a 'replace' too. Callers that must
+* not churn a running review (poll, reply) simply pass none.
+*/
+function assessRunningServer(health, repoPath, version, srcStamp = null) {
 	if (health?.ok !== true || health.repo !== repoPath) return "foreign";
-	return health.app === "diffo" && health.version === version ? "reuse" : "replace";
+	if (health.app !== "diffo" || health.version !== version) return "replace";
+	if (srcStamp !== null && health.srcStamp !== srcStamp) return "replace";
+	return "reuse";
 }
 /**
 * argv for the daemon: the same runtime flags executing this CLI, the same entry
@@ -3711,17 +4075,17 @@ async function retireServer(port, pid, reportedPid = null) {
 * 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 = () => {}) {
+async function settleExistingServer(db, repoPath, version, onStatus = () => {}, srcStamp = null) {
 	const record = db.getServer(repoPath);
 	if (!record) return null;
 	const health = await fetchHealth(record.port);
-	const verdict = assessRunningServer(health, repoPath, version);
+	const verdict = assessRunningServer(health, repoPath, version, srcStamp);
 	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})`);
+		onStatus(health?.version === version ? `replacing the dev server — the checkout's source changed since it started` : `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);
@@ -3781,7 +4145,7 @@ 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);
+		const existing = await settleExistingServer(db, opts.repoPath, opts.version, status, opts.srcStamp ?? null);
 		if (existing) return existing.port;
 		status("no diffo server for this repo — starting one");
 		mkdirSync(dirname(opts.logPath), { recursive: true });
@@ -3792,7 +4156,7 @@ async function ensureServer(opts, deps = {}) {
 		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;
+			if (assessRunningServer(await fetchHealth(row.port, 500), opts.repoPath, opts.version, opts.srcStamp ?? null) !== "reuse") return false;
 			port = row.port;
 			return true;
 		}, opts.spawnTimeoutMs ?? 8e3) || port === null) {
@@ -4201,10 +4565,15 @@ if (command.kind === "setup") {
 const root = findRepoRoot(process.cwd());
 if (!root) fail("not inside a git repository");
 const repoPath = resolve(root);
+/**
+* Only the open path settles with the source stamp: opening a review is the
+* moment "run the current source" is the promise, while poll/reply/comment must
+* never restart the server under a review in progress.
+*/
 async function discoverServer() {
 	const db = new DiffoDb();
 	try {
-		return await settleExistingServer(db, repoPath, VERSION, (line) => process.stderr.write(`diffo: ${line}\n`));
+		return await settleExistingServer(db, repoPath, VERSION, (line) => process.stderr.write(`diffo: ${line}\n`), SRC_STAMP);
 	} catch (err) {
 		fail(err.message);
 	} finally {
@@ -4218,7 +4587,7 @@ function sessionHeaders() {
 		...pid === null ? {} : { "x-diffo-session-pid": String(pid) }
 	};
 }
-async function requireServer(port, base) {
+async function requireServer(port, base, srcStamp = null) {
 	try {
 		return await ensureServer({
 			repoPath,
@@ -4228,6 +4597,7 @@ async function requireServer(port, base) {
 			execArgv: process.execArgv,
 			port,
 			base,
+			srcStamp,
 			logPath: process.env.DIFFO_SERVER_LOG || defaultLogPath(repoPath),
 			onStatus: (line) => process.stderr.write(`diffo: ${line}\n`)
 		});
@@ -4343,7 +4713,7 @@ if (command.kind === "status") {
 		db.close();
 	}
 	const health = record ? await fetchHealth(record.port) : null;
-	const verdict = record ? assessRunningServer(health, repoPath, VERSION) : "foreign";
+	const verdict = record ? assessRunningServer(health, repoPath, VERSION, SRC_STAMP) : "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");
@@ -4362,7 +4732,7 @@ if (command.kind === "status") {
 		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(`server: port ${record.port}${pid ? ` · pid ${pid}` : ""} · v${health?.version ?? "pre-handshake"}` + (verdict === "replace" ? health?.version === VERSION ? ` (the checkout's source changed — the next \`diffo\` replaces it)` : ` (this CLI is v${VERSION} — the next \`diffo\` replaces it)` : ""));
 	console.log(`→ ${url}`);
 	process.exit(0);
 }
@@ -4390,7 +4760,7 @@ if (command.kind === "stop") {
 }
 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");
+	process.stderr.write("diffo: waiting for the reviewer — keep this process attended: a tracked\nbackground task or the foreground, never detached. If it dies, just\nre-run it — feedback is held in the review and survives.\n");
 	try {
 		const res = await fetch(apiUrl(port, "/api/agent/poll"), { headers: sessionHeaders() });
 		if (!res.ok) fail(`poll failed (${res.status})`);
@@ -4413,7 +4783,8 @@ if (command.kind === "reply") {
 	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
+		text: message,
+		...command.more ? { more: true } : {}
 	});
 	if (status === 404) fail(`no thread with id '${command.threadId}'`);
 	if (status !== 200) fail(`reply failed (${status})`);
@@ -4422,7 +4793,7 @@ if (command.kind === "reply") {
 		ok: true,
 		threadId: thread.id,
 		state: thread.state,
-		next_step: ACK_NEXT_STEP.reply
+		next_step: command.more ? ACK_NEXT_STEP.replyMore : ACK_NEXT_STEP.reply
 	}));
 	process.exit(0);
 }
@@ -4472,6 +4843,32 @@ async function printAgentNextStep(port) {
 	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)");
 }
+/**
+* Dev builds serve the client from the checkout's `dist/client`, which nothing
+* rebuilds on its own — so opening a review after a source edit showed last
+* build's UI over this build's server. Rebuild it here, before the server is
+* settled: the server reads client files from disk per request, so even a
+* reused server serves the fresh bundle. `.dev-stamp` (written after a
+* successful build, into a directory vite has just emptied) makes the no-change
+* open free. The foreground path is exempt — that is `pnpm dev:server`'s tsx
+* watch loop, where the client is vite's dev server, not this bundle.
+*/
+function rebuildDevClient(foreground) {
+	if (SRC_STAMP === null || foreground) return;
+	const stampFile = join(CHECKOUT_ROOT, "dist", "client", ".dev-stamp");
+	try {
+		if (readFileSync(stampFile, "utf-8").trim() === SRC_STAMP) return;
+	} catch {}
+	process.stderr.write(`diffo: dev checkout changed — rebuilding the client bundle\n`);
+	const vite = join(CHECKOUT_ROOT, "node_modules", ".bin", process.platform === "win32" ? "vite.cmd" : "vite");
+	const built = spawnSync(vite, ["build"], {
+		cwd: CHECKOUT_ROOT,
+		encoding: "utf-8"
+	});
+	if (built.status !== 0) fail(`the client rebuild failed — fix the build, then re-run\n${(built.stderr || built.stdout || String(built.error ?? "")).trim().slice(-2e3)}`);
+	writeFileSync(stampFile, `${SRC_STAMP}\n`);
+}
+rebuildDevClient(command.foreground);
 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) {
@@ -4496,7 +4893,7 @@ if (existing !== null && takeOverPort !== null) {
 	db.close();
 }
 if (!command.foreground) {
-	const daemonPort = await requireServer(command.port, command.spec.kind === "branch" ? command.spec.base : void 0);
+	const daemonPort = await requireServer(command.port, command.spec.kind === "branch" ? command.spec.base : void 0, SRC_STAMP);
 	const url = reviewUrl(daemonPort);
 	await printChangesetSummary(daemonPort);
 	console.log(`→ ${url}`);