@diffohq/diffo 0.0.2 → 0.1.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,6 +219,7 @@ 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.`;
 }
@@ -341,20 +370,83 @@ 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 (!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 ?? []);
@@ -381,6 +473,23 @@ function buildCoalescedPrompt(threads, ctx) {
 		""
 	].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");
+}
 function buildFinishPrompt(threads, ctx, coverage) {
 	const repo = ctx.repo;
 	const sent = threads.filter((t) => t.state === "sent");
@@ -396,7 +505,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,7 +517,6 @@ 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}`,
@@ -417,8 +524,10 @@ function buildFinishPrompt(threads, ctx, coverage) {
 		...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), "");
+	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), "");
 	return parts.join("\n");
 }
 //#endregion
@@ -849,6 +958,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;
@@ -1507,7 +1667,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";
@@ -1635,7 +1795,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 +1925,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 +1992,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 +2014,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);
@@ -1981,6 +2158,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 +2179,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 +2191,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 +2202,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 +2266,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(),
@@ -2454,7 +2653,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 +2687,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 +2703,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,6 +2743,7 @@ 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.closingNote === true ? { closingNote: true } : {},
@@ -3007,7 +3221,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?.());
@@ -3065,14 +3280,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);
@@ -3117,8 +3332,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 +3375,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 +3387,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,12 +3479,21 @@ function createApp(ctx, store, review, queue) {
 	});
 	const pollPayload = (snapshot) => {
 		const threads = review?.get().threads ?? [];
+		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" && t.messages.at(-1)?.author === "reviewer").map((t) => t.id),
 				prompt: buildFinishPrompt(batch, {
 					repo: repoInfo(),
 					changeset: store?.get() ?? null
@@ -3549,8 +3774,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 +3786,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) {
@@ -3635,9 +3862,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 +3946,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 +4016,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 +4027,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 +4436,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 +4458,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 +4468,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 +4584,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 +4603,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);
 }
@@ -4472,6 +4713,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 +4763,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}`);