diffing 0.1.2 → 0.2.1

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { _ as gitAddFile, a as formatComments, b as revertHunk, c as getFileContent, d as getMergeStatus, f as getProjectStorageDir, g as getUntrackedFilePathsAsync, h as getTabSizeForFiles, i as writeServerLock, l as getGitDiffAsync, m as getRepoRoot, o as getBranchName, p as getRepoName, r as removeServerLock, s as getCustomGitDiffAsync, u as getHunkHistory, v as isGitRepo, x as isSafePath, y as listRepoFiles } from "./server-lock-DbxpfF3j.mjs";
+import { C as revertHunk, S as listRepoFiles, T as toSafeRelativePath, _ as getRepoRoot, a as extractPlanLines, b as gitAddFile, c as formatComments, d as getFileContent, f as getGitDiffAsync, g as getRepoName, h as getProjectStorageDir, i as writeServerLock, l as getBranchName, m as getMergeStatus, o as formatPlanReview, p as getHunkHistory, r as removeServerLock, s as sectionTitleForLine, u as getCustomGitDiffAsync, v as getTabSizeForFiles, w as isSafePath, x as isGitRepo, y as getUntrackedFilePathsAsync } from "./server-lock-DpCrvL-Z.mjs";
 import { fileURLToPath } from "node:url";
 import { dirname, extname, join, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "node:fs";
@@ -11,6 +11,7 @@ import { homedir } from "node:os";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { serve } from "@hono/node-server";
+import { stdout } from "node:process";
 //#region src/lib/diff-options.ts
 const DEFAULTS$1 = {
 	revisions: [],
@@ -1112,7 +1113,10 @@ const DEFAULTS = {
 	expandContextByDefault: false,
 	collapsedContextThreshold: 10,
 	expansionLineCount: 20,
-	haptics: true
+	haptics: true,
+	sounds: true,
+	uiFont: null,
+	monoFont: null
 };
 function loadSettings() {
 	try {
@@ -1139,9 +1143,15 @@ function saveSettings(settings) {
 var FileCommentStore = class {
 	dirPath;
 	filePath;
-	constructor(customRepoRoot) {
-		if (customRepoRoot) this.dirPath = join(customRepoRoot, ".diffing");
-		else this.dirPath = getProjectStorageDir();
+	/**
+	* @param storageDir Absolute directory to persist `comments.json` in.
+	*   Defaults to the per-repo storage dir under `~/.diffing` — comments are
+	*   NEVER written inside the reviewed (consumer) repo, so a consumer project
+	*   stays free of any diffing-specific artifacts. The override exists only so
+	*   tests can point at a throwaway temp dir.
+	*/
+	constructor(storageDir) {
+		this.dirPath = storageDir ?? getProjectStorageDir();
 		this.filePath = join(this.dirPath, "comments.json");
 	}
 	async getAll() {
@@ -1222,6 +1232,212 @@ var FileCommentStore = class {
 	}
 };
 //#endregion
+//#region src/lib/plans.ts
+function newId() {
+	return crypto.randomUUID();
+}
+/** Shared mutation helpers so both stores behave identically. */
+function applyUpsert(plans, input, now) {
+	if (input.id) {
+		const existing = plans.find((p) => p.id === input.id);
+		if (existing) {
+			existing.title = input.title;
+			existing.body = input.body;
+			if (input.source !== void 0) existing.source = input.source;
+			if (input.model !== void 0) existing.model = input.model;
+			existing.version += 1;
+			existing.updatedAt = now;
+			existing.decision = "pending";
+			existing.decisionComment = void 0;
+			existing.decidedAt = void 0;
+			return existing;
+		}
+	}
+	const plan = {
+		id: input.id || newId(),
+		title: input.title,
+		body: input.body,
+		source: input.source,
+		model: input.model,
+		createdAt: now,
+		updatedAt: now,
+		version: 1,
+		decision: "pending",
+		comments: []
+	};
+	plans.push(plan);
+	return plan;
+}
+var FilePlanStore = class {
+	dirPath;
+	filePath;
+	/**
+	* @param storageDir Absolute directory to persist `plans.json` in. Defaults
+	*   to the per-repo storage dir under `~/.diffing`, the same place comments
+	*   and media live — plans are NEVER written inside the reviewed (consumer)
+	*   repo, so a consumer project stays free of any diffing-specific artifacts.
+	*   The override exists only so tests can point at a throwaway temp dir.
+	*/
+	constructor(storageDir) {
+		this.dirPath = storageDir ?? getProjectStorageDir();
+		this.filePath = join(this.dirPath, "plans.json");
+	}
+	async getAll() {
+		try {
+			const data = await readFile(this.filePath, "utf-8");
+			return JSON.parse(data);
+		} catch {
+			return [];
+		}
+	}
+	async get(id) {
+		return (await this.getAll()).find((p) => p.id === id) ?? null;
+	}
+	async save(plans) {
+		try {
+			await mkdir(this.dirPath, { recursive: true });
+			try {
+				const repoRoot = getRepoRoot();
+				await writeFile(join(this.dirPath, "repo_path.txt"), repoRoot, "utf-8");
+			} catch {}
+			await writeFile(this.filePath, JSON.stringify(plans, null, 2), "utf-8");
+		} catch (err) {
+			console.error("Failed to save plans to file:", err);
+		}
+	}
+	async upsert(input) {
+		const plans = await this.getAll();
+		const plan = applyUpsert(plans, input, Date.now());
+		await this.save(plans);
+		return plan;
+	}
+	async update(id, fields) {
+		const plans = await this.getAll();
+		const plan = plans.find((p) => p.id === id);
+		if (!plan) return null;
+		if (fields.title !== void 0) plan.title = fields.title;
+		if (fields.body !== void 0) plan.body = fields.body;
+		if (fields.source !== void 0) plan.source = fields.source;
+		if (fields.model !== void 0) plan.model = fields.model;
+		plan.updatedAt = Date.now();
+		await this.save(plans);
+		return plan;
+	}
+	async remove(id) {
+		const plans = await this.getAll();
+		const idx = plans.findIndex((p) => p.id === id);
+		if (idx === -1) return false;
+		plans.splice(idx, 1);
+		await this.save(plans);
+		return true;
+	}
+	async setDecision(id, decision, decisionComment) {
+		const plans = await this.getAll();
+		const plan = plans.find((p) => p.id === id);
+		if (!plan) return null;
+		plan.decision = decision;
+		plan.decisionComment = decisionComment?.trim() || void 0;
+		plan.decidedAt = Date.now();
+		plan.updatedAt = plan.decidedAt;
+		await this.save(plans);
+		return plan;
+	}
+	async mutate(planId, fn) {
+		const plans = await this.getAll();
+		const plan = plans.find((p) => p.id === planId);
+		if (!plan) return null;
+		if (!plan.comments) plan.comments = [];
+		if (!fn(plan)) return null;
+		await this.save(plans);
+		return plan;
+	}
+	async addComment(planId, comment) {
+		return this.mutate(planId, (plan) => {
+			plan.comments.push(comment);
+			return true;
+		});
+	}
+	async updateComment(planId, commentId, fields) {
+		return this.mutate(planId, (plan) => {
+			const c = plan.comments.find((x) => x.id === commentId);
+			if (!c) return false;
+			if (fields.body !== void 0) c.body = fields.body;
+			if (fields.status !== void 0) c.status = fields.status;
+			return true;
+		});
+	}
+	async removeComment(planId, commentId) {
+		return this.mutate(planId, (plan) => {
+			const idx = plan.comments.findIndex((x) => x.id === commentId);
+			if (idx === -1) return false;
+			plan.comments.splice(idx, 1);
+			return true;
+		});
+	}
+	async addReply(planId, commentId, reply) {
+		return this.mutate(planId, (plan) => {
+			const c = plan.comments.find((x) => x.id === commentId);
+			if (!c) return false;
+			if (!c.replies) c.replies = [];
+			c.replies.push(reply);
+			return true;
+		});
+	}
+	async removeReply(planId, commentId, replyId) {
+		return this.mutate(planId, (plan) => {
+			const c = plan.comments.find((x) => x.id === commentId);
+			if (!c) return false;
+			const idx = c.replies.findIndex((r) => r.id === replyId);
+			if (idx === -1) return false;
+			c.replies.splice(idx, 1);
+			return true;
+		});
+	}
+	async updateReply(planId, commentId, replyId, body) {
+		return this.mutate(planId, (plan) => {
+			const c = plan.comments.find((x) => x.id === commentId);
+			if (!c) return false;
+			const reply = c.replies.find((r) => r.id === replyId);
+			if (!reply) return false;
+			reply.body = body;
+			return true;
+		});
+	}
+};
+//#endregion
+//#region src/lib/state.ts
+var FileUiStateStore = class {
+	dirPath;
+	filePath;
+	constructor(storageDir) {
+		this.dirPath = storageDir ?? getProjectStorageDir();
+		this.filePath = join(this.dirPath, "ui-state.json");
+	}
+	async getAll() {
+		try {
+			const data = await readFile(this.filePath, "utf-8");
+			return JSON.parse(data);
+		} catch {
+			return {};
+		}
+	}
+	async setAll(state) {
+		await this.save(state);
+	}
+	async save(state) {
+		try {
+			await mkdir(this.dirPath, { recursive: true });
+			try {
+				const repoRoot = getRepoRoot();
+				await writeFile(join(this.dirPath, "repo_path.txt"), repoRoot, "utf-8");
+			} catch {}
+			await writeFile(this.filePath, JSON.stringify(state, null, 2), "utf-8");
+		} catch (err) {
+			console.error("Failed to save UI state to file:", err);
+		}
+	}
+};
+//#endregion
 //#region src/lib/review-session.ts
 var ReviewSession = class {
 	round = 0;
@@ -1285,7 +1501,8 @@ var ReviewSession = class {
 			sentAt: input.sentAt,
 			commentXml: input.commentXml,
 			openCount: input.openCount,
-			comments: input.comments
+			comments: input.comments,
+			decision: input.decision
 		};
 		this.lastPayload = payload;
 		const waiters = [...this.waiters];
@@ -1319,6 +1536,100 @@ var ReviewSession = class {
 	}
 };
 //#endregion
+//#region src/lib/plan-review-session.ts
+var PlanReviewSession = class {
+	round = 0;
+	lastDecidedAt = null;
+	lastPayload = null;
+	waiters = /* @__PURE__ */ new Set();
+	onStatusChange;
+	constructor(onStatusChange) {
+		this.onStatusChange = onStatusChange;
+	}
+	/** Block until the next `decide()` or until `timeoutMs` elapses. */
+	await(opts) {
+		const { sinceRound, timeoutMs, signal } = opts;
+		if (sinceRound !== void 0 && sinceRound < this.round && this.lastPayload) return Promise.resolve({
+			status: "released",
+			payload: this.lastPayload
+		});
+		if (signal?.aborted) return Promise.resolve({
+			status: "keep-waiting",
+			round: this.round
+		});
+		return new Promise((resolve) => {
+			const waiter = {
+				resolve,
+				timer: setTimeout(() => {
+					this.removeWaiter(waiter);
+					resolve({
+						status: "keep-waiting",
+						round: this.round
+					});
+				}, timeoutMs),
+				cleanup: () => {}
+			};
+			if (signal) {
+				const onAbort = () => {
+					this.removeWaiter(waiter);
+					resolve({
+						status: "keep-waiting",
+						round: this.round
+					});
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				waiter.cleanup = () => signal.removeEventListener("abort", onAbort);
+			}
+			this.waiters.add(waiter);
+			this.emitStatus();
+		});
+	}
+	/** Capture a decision and release every blocked waiter. */
+	decide(input) {
+		this.round += 1;
+		this.lastDecidedAt = input.sentAt;
+		const payload = {
+			round: this.round,
+			sentAt: input.sentAt,
+			planId: input.planId,
+			decision: input.decision,
+			decisionComment: input.decisionComment,
+			reviewXml: input.reviewXml,
+			openCommentCount: input.openCommentCount,
+			plan: input.plan
+		};
+		this.lastPayload = payload;
+		const waiters = [...this.waiters];
+		this.waiters.clear();
+		for (const waiter of waiters) {
+			clearTimeout(waiter.timer);
+			waiter.cleanup();
+			waiter.resolve({
+				status: "released",
+				payload
+			});
+		}
+		this.emitStatus();
+		return payload;
+	}
+	snapshot() {
+		return {
+			round: this.round,
+			waiters: this.waiters.size,
+			lastDecidedAt: this.lastDecidedAt
+		};
+	}
+	removeWaiter(waiter) {
+		if (!this.waiters.delete(waiter)) return;
+		clearTimeout(waiter.timer);
+		waiter.cleanup();
+		this.emitStatus();
+	}
+	emitStatus() {
+		this.onStatusChange?.(this.snapshot());
+	}
+};
+//#endregion
 //#region src/server.ts
 const MIME_TYPES = {
 	".html": "text/html",
@@ -1338,10 +1649,12 @@ const MIME_TYPES = {
 function isCustomMode(opts) {
 	return opts.revisions.length > 0 || opts.pathspecs.length > 0;
 }
-function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
+function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 	const app = new Hono();
 	const customMode = isCustomMode(diffOpts);
 	const store = commentStore ?? new FileCommentStore();
+	const plans = planStore ?? new FilePlanStore();
+	const uiStateStore = new FileUiStateStore();
 	const viewedFiles = /* @__PURE__ */ new Set();
 	const activeClients = /* @__PURE__ */ new Set();
 	const broadcast = (event, data) => {
@@ -1350,23 +1663,30 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 		} catch {}
 	};
 	const reviewSession = new ReviewSession((snapshot) => broadcast("agent-status", JSON.stringify(snapshot)));
+	const planReviewSession = new PlanReviewSession((snapshot) => broadcast("plan-review-status", JSON.stringify(snapshot)));
 	let repoRoot;
 	try {
 		repoRoot = getRepoRoot();
 	} catch {
 		repoRoot = process.cwd();
 	}
-	if (!commentStore) try {
+	if (!commentStore && !planStore) try {
 		const storageDir = getProjectStorageDir();
 		mkdirSync(storageDir, { recursive: true });
 		let commentsDebounce = null;
+		let plansDebounce = null;
 		watch(storageDir, (_eventType, filename) => {
-			if (filename && !filename.startsWith("comments.json")) return;
-			if (commentsDebounce) clearTimeout(commentsDebounce);
-			commentsDebounce = setTimeout(() => broadcast("comments", Date.now().toString()), 120);
+			if (!filename) return;
+			if (filename.startsWith("comments.json")) {
+				if (commentsDebounce) clearTimeout(commentsDebounce);
+				commentsDebounce = setTimeout(() => broadcast("comments", Date.now().toString()), 120);
+			} else if (filename.startsWith("plans.json")) {
+				if (plansDebounce) clearTimeout(plansDebounce);
+				plansDebounce = setTimeout(() => broadcast("plans", Date.now().toString()), 120);
+			}
 		}).unref();
 	} catch (err) {
-		console.warn("Failed to initialize comment store watcher:", err);
+		console.warn("Failed to initialize storage watcher:", err);
 	}
 	let debounceTimeout = null;
 	try {
@@ -1468,8 +1788,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 		if (!filePath) return c.json({ error: "filePath is required" }, 400);
 		try {
 			const root = getRepoRoot();
-			if (!isSafePath(filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
-			const absolutePath = resolve(root, filePath);
+			const relPath = toSafeRelativePath(filePath, root);
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			const absolutePath = resolve(root, relPath);
 			const { exec } = await import("node:child_process");
 			if (editor === "vscode") exec(`code "${absolutePath}"`);
 			else if (editor === "zed") exec(`zed "${absolutePath}"`);
@@ -1543,8 +1864,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 		const { filePath, hunkIndex } = await c.req.json();
 		if (!filePath || typeof hunkIndex !== "number") return c.json({ error: "Missing filePath or hunkIndex" }, 400);
 		try {
-			if (!isSafePath(filePath, getRepoRoot())) return c.json({ error: "Forbidden file path" }, 403);
-			revertHunk(filePath, hunkIndex);
+			const relPath = toSafeRelativePath(filePath, getRepoRoot());
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			revertHunk(relPath, hunkIndex);
 			return c.json({ ok: true });
 		} catch (err) {
 			const stderr = typeof err?.stderr === "string" ? err.stderr : err?.stderr instanceof Buffer ? err.stderr.toString("utf-8") : "";
@@ -1557,8 +1879,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 		const deletionCount = Number(c.req.query("deletionCount"));
 		if (!filePath || Number.isNaN(deletionStart) || Number.isNaN(deletionCount)) return c.json({ error: "Missing or invalid parameters" }, 400);
 		try {
-			if (!isSafePath(filePath, getRepoRoot())) return c.json({ error: "Forbidden file path" }, 403);
-			const history = getHunkHistory(filePath, deletionStart, deletionCount, diffOpts.revisions[0] || "HEAD");
+			const relPath = toSafeRelativePath(filePath, getRepoRoot());
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			const history = getHunkHistory(relPath, deletionStart, deletionCount, diffOpts.revisions[0] || "HEAD");
 			return c.json(history);
 		} catch (err) {
 			return c.json({ error: err.message || "Failed to fetch hunk history" }, 500);
@@ -1569,10 +1892,11 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 		if (!filePath || typeof content !== "string") return c.json({ error: "Missing filePath or content" }, 400);
 		try {
 			const root = getRepoRoot();
-			if (!isSafePath(filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
-			await writeFile(resolve(root, filePath), content, "utf-8");
+			const relPath = toSafeRelativePath(filePath, root);
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			await writeFile(resolve(root, relPath), content, "utf-8");
 			if (gitAdd) try {
-				gitAddFile(filePath);
+				gitAddFile(relPath);
 			} catch (err) {
 				return c.json({
 					ok: true,
@@ -1591,6 +1915,19 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 		const settings = saveSettings(await c.req.json());
 		return c.json(settings);
 	});
+	app.get("/api/ui-state", async (c) => {
+		return c.json(await uiStateStore.getAll());
+	});
+	app.put("/api/ui-state", async (c) => {
+		const body = await c.req.json();
+		const merged = {
+			...await uiStateStore.getAll(),
+			...body
+		};
+		for (const key of Object.keys(body)) if (body[key] === null || body[key] === void 0) delete merged[key];
+		await uiStateStore.setAll(merged);
+		return c.json(merged);
+	});
 	app.get("/api/viewed", (c) => {
 		return c.json([...viewedFiles]);
 	});
@@ -1671,8 +2008,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 		const suggestion = match[1];
 		try {
 			const root = getRepoRoot();
-			if (!isSafePath(comment.filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
-			const absolutePath = resolve(root, comment.filePath);
+			const relPath = toSafeRelativePath(comment.filePath, root);
+			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
+			const absolutePath = resolve(root, relPath);
 			const lines = (await readFile(absolutePath, "utf-8")).split(/\r?\n/);
 			const lineIdx = comment.lineNumber - 1;
 			if (lineIdx < 0 || lineIdx >= lines.length) return c.json({ error: "Comment line number out of range" }, 400);
@@ -1692,18 +2030,21 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 	app.post("/api/review/send", async (c) => {
 		const body = await c.req.json().catch(() => ({}));
 		const generalComment = typeof body?.generalComment === "string" ? body.generalComment : void 0;
+		const decision = body?.decision === "approved" || body?.decision === "changes-requested" || body?.decision === "rejected" ? body.decision : void 0;
 		const all = await store.getAll();
 		const openCount = all.filter((x) => x.status === "open").length;
 		const payload = reviewSession.send({
 			sentAt: Date.now(),
-			commentXml: formatComments(all, generalComment),
+			commentXml: formatComments(all, generalComment, decision),
 			openCount,
-			comments: all
+			comments: all,
+			decision
 		});
 		return c.json({
 			ok: true,
 			round: payload.round,
 			openCount: payload.openCount,
+			decision: payload.decision,
 			waiters: reviewSession.snapshot().waiters
 		});
 	});
@@ -1722,6 +2063,148 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 	app.get("/api/review/status", (c) => {
 		return c.json(reviewSession.snapshot());
 	});
+	app.get("/api/plans", async (c) => {
+		return c.json(await plans.getAll());
+	});
+	app.get("/api/plans/:id", async (c) => {
+		const plan = await plans.get(c.req.param("id"));
+		if (!plan) return c.json({ error: "Plan not found" }, 404);
+		return c.json(plan);
+	});
+	app.post("/api/plans", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		if (typeof body.body !== "string" || !body.body.trim()) return c.json({ error: "A plan body (markdown) is required" }, 400);
+		const title = typeof body.title === "string" && body.title.trim() ? body.title.trim() : "Untitled plan";
+		const plan = await plans.upsert({
+			id: typeof body.id === "string" && body.id ? body.id : void 0,
+			title,
+			body: body.body,
+			source: typeof body.source === "string" ? body.source : void 0,
+			model: typeof body.model === "string" ? body.model : void 0
+		});
+		return c.json(plan, 201);
+	});
+	app.put("/api/plans/:id", async (c) => {
+		const id = c.req.param("id");
+		const { title, body, source, model } = await c.req.json().catch(() => ({}));
+		const updated = await plans.update(id, {
+			title: typeof title === "string" ? title : void 0,
+			body: typeof body === "string" ? body : void 0,
+			source: typeof source === "string" ? source : void 0,
+			model: typeof model === "string" ? model : void 0
+		});
+		if (!updated) return c.json({ error: "Plan not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/plans/:id", async (c) => {
+		if (!await plans.remove(c.req.param("id"))) return c.json({ error: "Plan not found" }, 404);
+		return c.json({ ok: true });
+	});
+	app.post("/api/plans/:id/comments", async (c) => {
+		const planId = c.req.param("id");
+		const plan = await plans.get(planId);
+		if (!plan) return c.json({ error: "Plan not found" }, 404);
+		const body = await c.req.json();
+		const lineNumber = Number.isFinite(body.lineNumber) ? Number(body.lineNumber) : 0;
+		const startLineNumber = Number.isFinite(body.startLineNumber) ? Number(body.startLineNumber) : void 0;
+		const anchorStart = startLineNumber ?? lineNumber;
+		const lineContent = typeof body.lineContent === "string" && body.lineContent ? body.lineContent : lineNumber > 0 ? extractPlanLines(plan.body, anchorStart, lineNumber) : "";
+		const sectionTitle = typeof body.sectionTitle === "string" && body.sectionTitle ? body.sectionTitle : lineNumber > 0 ? sectionTitleForLine(plan.body, anchorStart) : void 0;
+		const comment = {
+			id: crypto.randomUUID(),
+			lineNumber,
+			startLineNumber,
+			lineContent,
+			sectionTitle,
+			body: body.body,
+			status: "open",
+			createdAt: Date.now(),
+			replies: []
+		};
+		const updated = await plans.addComment(planId, comment);
+		if (!updated) return c.json({ error: "Plan not found" }, 404);
+		return c.json(updated, 201);
+	});
+	app.put("/api/plans/:id/comments/:commentId", async (c) => {
+		const { body, status } = await c.req.json();
+		const updated = await plans.updateComment(c.req.param("id"), c.req.param("commentId"), {
+			body,
+			status
+		});
+		if (!updated) return c.json({ error: "Plan or comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/plans/:id/comments/:commentId", async (c) => {
+		const updated = await plans.removeComment(c.req.param("id"), c.req.param("commentId"));
+		if (!updated) return c.json({ error: "Plan or comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.post("/api/plans/:id/comments/:commentId/replies", async (c) => {
+		const { body, role, model } = await c.req.json();
+		const reply = {
+			id: crypto.randomUUID(),
+			body,
+			createdAt: Date.now(),
+			role: role || (model ? "agent" : "user"),
+			model: model || void 0
+		};
+		const updated = await plans.addReply(c.req.param("id"), c.req.param("commentId"), reply);
+		if (!updated) return c.json({ error: "Plan or comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.put("/api/plans/:id/comments/:commentId/replies/:replyId", async (c) => {
+		const { body } = await c.req.json();
+		if (!body) return c.json({ error: "Body is required" }, 400);
+		const updated = await plans.updateReply(c.req.param("id"), c.req.param("commentId"), c.req.param("replyId"), body);
+		if (!updated) return c.json({ error: "Plan, comment, or reply not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/plans/:id/comments/:commentId/replies/:replyId", async (c) => {
+		const updated = await plans.removeReply(c.req.param("id"), c.req.param("commentId"), c.req.param("replyId"));
+		if (!updated) return c.json({ error: "Plan, comment, or reply not found" }, 404);
+		return c.json(updated);
+	});
+	app.post("/api/plans/:id/decision", async (c) => {
+		const planId = c.req.param("id");
+		const body = await c.req.json().catch(() => ({}));
+		const decision = body.decision;
+		if (decision !== "approved" && decision !== "rejected" && decision !== "changes-requested") return c.json({ error: "decision must be one of: approved, rejected, changes-requested" }, 400);
+		const decisionComment = typeof body.decisionComment === "string" ? body.decisionComment : void 0;
+		const plan = await plans.setDecision(planId, decision, decisionComment);
+		if (!plan) return c.json({ error: "Plan not found" }, 404);
+		const openCommentCount = (plan.comments ?? []).filter((x) => x.status === "open").length;
+		const payload = planReviewSession.decide({
+			sentAt: Date.now(),
+			planId,
+			decision,
+			decisionComment: plan.decisionComment,
+			reviewXml: formatPlanReview(plan),
+			openCommentCount,
+			plan
+		});
+		return c.json({
+			ok: true,
+			round: payload.round,
+			decision,
+			openCommentCount,
+			waiters: planReviewSession.snapshot().waiters
+		});
+	});
+	app.get("/api/plan-review/await", async (c) => {
+		const sinceRaw = c.req.query("sinceRound");
+		const sinceRound = sinceRaw !== void 0 && sinceRaw !== "" ? Number(sinceRaw) : void 0;
+		const requested = Number(c.req.query("timeoutMs")) || 25e3;
+		const timeoutMs = Math.min(Math.max(requested, 1e3), 5e4);
+		const result = await planReviewSession.await({
+			sinceRound: Number.isNaN(sinceRound) ? void 0 : sinceRound,
+			timeoutMs,
+			signal: c.req.raw.signal
+		});
+		return c.json(result);
+	});
+	app.get("/api/plan-review/status", (c) => {
+		return c.json(planReviewSession.snapshot());
+	});
 	app.post("/api/attachments", async (c) => {
 		const file = (await c.req.parseBody())["file"];
 		if (!file || !(file instanceof File)) return c.json({ error: "No file uploaded" }, 400);
@@ -1771,6 +2254,40 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
 	});
 	return app;
 }
+/**
+* Newest mtime (epoch ms) across everything that counts as project activity:
+* comments.json, plans.json, and any attachment (media) file. Plans and media
+* extend a project's life exactly like comments do, so retention is uniform
+* across all three. Returns null when none of them exist yet.
+*/
+async function newestActivityMs(projectDir) {
+	const candidates = [];
+	const safeStat = async (p) => {
+		try {
+			return (await stat(p)).mtimeMs;
+		} catch {
+			return null;
+		}
+	};
+	for (const name of ["comments.json", "plans.json"]) {
+		const file = join(projectDir, name);
+		if (!existsSync(file)) continue;
+		const m = await safeStat(file);
+		if (m !== null) candidates.push(m);
+	}
+	const attachmentsDir = join(projectDir, "attachments");
+	if (existsSync(attachmentsDir)) {
+		const dirM = await safeStat(attachmentsDir);
+		if (dirM !== null) candidates.push(dirM);
+		try {
+			for (const file of await readdir(attachmentsDir)) {
+				const m = await safeStat(join(attachmentsDir, file));
+				if (m !== null) candidates.push(m);
+			}
+		} catch {}
+	}
+	return candidates.length ? Math.max(...candidates) : null;
+}
 async function cleanupStaleProjects() {
 	const baseDir = join(homedir(), ".diffing");
 	if (!existsSync(baseDir)) return;
@@ -1781,15 +2298,15 @@ async function cleanupStaleProjects() {
 		for (const entry of entries) if (entry.isDirectory()) {
 			const projectDir = join(baseDir, entry.name);
 			const repoPathFile = join(projectDir, "repo_path.txt");
-			const commentsFile = join(projectDir, "comments.json");
 			let shouldDelete = false;
 			if (existsSync(repoPathFile)) try {
 				const repoPath = (await readFile(repoPathFile, "utf-8")).trim();
 				if (!repoPath || !existsSync(repoPath)) shouldDelete = true;
 			} catch {}
-			if (!shouldDelete && existsSync(commentsFile)) try {
-				if (now - (await stat(commentsFile)).mtimeMs > STALE_TIME) shouldDelete = true;
-			} catch {}
+			if (!shouldDelete) {
+				const newest = await newestActivityMs(projectDir);
+				if (newest !== null && now - newest > STALE_TIME) shouldDelete = true;
+			}
 			if (shouldDelete) await rm(projectDir, {
 				recursive: true,
 				force: true
@@ -1815,6 +2332,389 @@ function startServer(options) {
 	});
 }
 //#endregion
+//#region src/lib/startup-display.ts
+const R = "\x1B[0m";
+const B = "\x1B[1m";
+const HIDE = "\x1B[?25l";
+const SHOW = "\x1B[?25h";
+const CLR = "\x1B[2K\r";
+const GLITCH_CHARS = "░▒▓█▄▀■□▸▹◆◇";
+const c = (n) => `\x1b[38;5;${n}m`;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const up = (n) => `\x1b[${n}A`;
+const PALETTES = [
+	{
+		base: c(51),
+		text: c(159),
+		faint: c(30),
+		glow: B + c(87),
+		rain: c(37)
+	},
+	{
+		base: c(82),
+		text: c(155),
+		faint: c(22),
+		glow: B + c(118),
+		rain: c(34)
+	},
+	{
+		base: c(207),
+		text: c(219),
+		faint: c(96),
+		glow: B + c(213),
+		rain: c(128)
+	},
+	{
+		base: c(220),
+		text: c(229),
+		faint: c(136),
+		glow: B + c(226),
+		rain: c(178)
+	},
+	{
+		base: c(75),
+		text: c(153),
+		faint: c(25),
+		glow: B + c(81),
+		rain: c(39)
+	},
+	{
+		base: c(214),
+		text: c(223),
+		faint: c(130),
+		glow: B + c(208),
+		rain: c(172)
+	}
+];
+const QUOTES = [
+	{
+		text: "The best code is no code at all.",
+		author: "Jeff Atwood"
+	},
+	{
+		text: "Programs must be written for people to read, and only incidentally for machines to execute.",
+		author: "Abelson & Sussman"
+	},
+	{
+		text: "Make it work, make it right, make it fast.",
+		author: "Kent Beck"
+	},
+	{
+		text: "Simplicity is the soul of efficiency.",
+		author: "Austin Freeman"
+	},
+	{
+		text: "Any fool can write code that a computer can understand. Good programmers write code that humans can understand.",
+		author: "Martin Fowler"
+	},
+	{
+		text: "First, solve the problem. Then, write the code.",
+		author: "John Johnson"
+	},
+	{
+		text: "Code is like humor. When you have to explain it, it's bad.",
+		author: "Cory House"
+	},
+	{
+		text: "Before software can be reusable it first has to be usable.",
+		author: "Ralph Johnson"
+	},
+	{
+		text: "Clean code always looks like it was written by someone who cares.",
+		author: "Robert C. Martin"
+	},
+	{
+		text: "The most dangerous phrase is \"we've always done it this way\".",
+		author: "Grace Hopper"
+	},
+	{
+		text: "Architecture is the decisions you wish you could get right early in a project.",
+		author: "Martin Fowler"
+	},
+	{
+		text: "The best error message is the one that never shows up.",
+		author: "Thomas Fuchs"
+	},
+	{
+		text: "It works on my machine.",
+		author: "Every developer, always"
+	},
+	{
+		text: "git blame yourself.",
+		author: "The terminal"
+	},
+	{
+		text: "There are only two hard things in CS: cache invalidation, naming things, and off-by-one errors.",
+		author: "Unknown"
+	},
+	{
+		text: "Debugging: being the detective in a crime movie where you're also the murderer.",
+		author: "Unknown"
+	},
+	{
+		text: "The code you wrote six months ago was written by an idiot.",
+		author: "Unknown"
+	},
+	{
+		text: "sudo make me a sandwich.",
+		author: "xkcd"
+	},
+	{
+		text: "I don't always test my code, but when I do, I do it in production.",
+		author: "Unknown"
+	},
+	{
+		text: "A QA engineer walks into a bar. Orders 0 beers. Orders 999999 beers. Orders NULL beers. Walks in through the window.",
+		author: "Unknown"
+	},
+	{
+		text: "To understand recursion, you must first understand recursion.",
+		author: "Unknown"
+	},
+	{
+		text: "The code review is the product.",
+		author: "diffing"
+	},
+	{
+		text: "Your abstractions are just someone else's bugs.",
+		author: "Unknown"
+	},
+	{
+		text: "Every rewrite is a confession that you didn't understand the problem the first time.",
+		author: "Unknown"
+	},
+	{
+		text: "The best PR is no PR — ship it in the design.",
+		author: "Unknown"
+	},
+	{
+		text: "You don't own your code. Your code owns you.",
+		author: "Unknown"
+	},
+	{
+		text: "A diff is a conversation. What story does yours tell?",
+		author: "Unknown"
+	},
+	{
+		text: "The senior engineer's superpower: knowing which shortcuts will haunt you.",
+		author: "Unknown"
+	},
+	{
+		text: "Production is the only real test environment.",
+		author: "Site Reliability truth"
+	},
+	{
+		text: "Tech debt is just deferred thinking.",
+		author: "Unknown"
+	},
+	{
+		text: "Comments lie. Code never does.",
+		author: "Ron Jeffries"
+	}
+];
+function wrapText(text, width) {
+	const words = text.split(" ");
+	const lines = [];
+	let cur = "";
+	for (const word of words) {
+		if (!cur) {
+			cur = word;
+			continue;
+		}
+		if (cur.length + 1 + word.length <= width) cur += " " + word;
+		else {
+			lines.push(cur);
+			cur = word;
+		}
+	}
+	if (cur) lines.push(cur);
+	return lines;
+}
+function makeBox(quote, pal) {
+	const termWidth = stdout.columns ?? 80;
+	const maxContent = Math.min(64, termWidth - 8);
+	const fullText = `"${quote.text}"`;
+	const authorStr = `— ${quote.author}`;
+	const textLines = wrapText(fullText, maxContent);
+	return {
+		textLines,
+		authorStr,
+		innerWidth: Math.max(...textLines.map((l) => l.length), authorStr.length, 28) + 4,
+		pal
+	};
+}
+function topBorder(b, borderCol = b.pal.base) {
+	return `${borderCol}╭${"─".repeat(b.innerWidth)}╮${R}`;
+}
+function bottomBorder(b, borderCol = b.pal.base) {
+	return `${borderCol}╰${"─".repeat(b.innerWidth)}╯${R}`;
+}
+function contentRow(b, text, borderCol = b.pal.base, textCol = b.pal.text) {
+	return `${borderCol}│${R}  ${textCol}${text}${R}${" ".repeat(b.innerWidth - 4 - text.length)}  ${borderCol}│${R}`;
+}
+function authorRow(b, borderCol = b.pal.base) {
+	const leading = " ".repeat(b.innerWidth - 4 - b.authorStr.length);
+	return `${borderCol}│${R}  ${b.pal.faint}${leading}${b.authorStr}${R}  ${borderCol}│${R}`;
+}
+function allLines(b, borderCol = b.pal.base) {
+	return [
+		topBorder(b, borderCol),
+		...b.textLines.map((l) => contentRow(b, l, borderCol)),
+		authorRow(b, borderCol),
+		bottomBorder(b, borderCol)
+	];
+}
+function printBox(b) {
+	for (const line of allLines(b)) stdout.write(line + "\n");
+}
+const animTypewriter = async (b) => {
+	stdout.write(topBorder(b) + "\n");
+	for (const line of b.textLines) {
+		stdout.write(`${b.pal.base}│${R}  `);
+		for (let i = 0; i < line.length; i++) {
+			const ch = line[i];
+			stdout.write(`${b.pal.text}${ch}${b.pal.glow}█${R}`);
+			await sleep(25);
+			stdout.write("\b \b");
+		}
+		for (let blink = 0; blink < 2; blink++) {
+			stdout.write(`${b.pal.glow}█${R}`);
+			await sleep(100);
+			stdout.write("\b \b");
+			await sleep(100);
+		}
+		stdout.write(" ".repeat(b.innerWidth - 4 - line.length) + `  ${b.pal.base}│${R}\n`);
+	}
+	stdout.write(authorRow(b) + "\n");
+	stdout.write(bottomBorder(b) + "\n");
+};
+const animWaveReveal = async (b) => {
+	stdout.write(topBorder(b) + "\n");
+	for (const line of b.textLines) {
+		const half = Math.ceil(line.length / 2);
+		stdout.write(contentRow(b, line.slice(0, half).padEnd(line.length), b.pal.base, b.pal.faint) + "\n");
+		await sleep(130);
+		stdout.write(up(1) + CLR + contentRow(b, line) + "\n");
+		await sleep(60);
+	}
+	stdout.write(authorRow(b) + "\n");
+	stdout.write(bottomBorder(b) + "\n");
+};
+const animSlide = async (b) => {
+	const lines = allLines(b);
+	for (let i = 0; i < lines.length; i++) stdout.write("\n");
+	stdout.write(up(lines.length));
+	for (let step = 0; step < 5; step++) {
+		const pad = " ".repeat(Math.floor(12 * (1 - step / 4)));
+		for (const line of lines) stdout.write(CLR + pad + line + "\n");
+		if (step < 4) {
+			stdout.write(up(lines.length));
+			await sleep(80);
+		}
+	}
+};
+const animPulseBorder = async (b) => {
+	const stages = [
+		allLines(b, b.pal.faint),
+		allLines(b, b.pal.base),
+		allLines(b, b.pal.glow),
+		allLines(b, b.pal.base)
+	];
+	for (let s = 0; s < stages.length; s++) {
+		if (s > 0) stdout.write(up(stages[0].length));
+		for (const line of stages[s]) stdout.write((s > 0 ? CLR : "") + line + "\n");
+		if (s < stages.length - 1) await sleep(180);
+	}
+};
+const animGlitch = async (b) => {
+	const noiseRates = [
+		.25,
+		.12,
+		.04,
+		0
+	];
+	const totalLines = b.textLines.length + 3;
+	for (let f = 0; f < noiseRates.length; f++) {
+		if (f > 0) stdout.write(up(totalLines));
+		const rate = noiseRates[f];
+		const clr = f > 0 ? CLR : "";
+		const jitter = rate > 0 ? Math.floor(Math.random() * 3) : 0;
+		const pad = " ".repeat(jitter);
+		stdout.write(clr + pad + topBorder(b) + "\n");
+		for (const line of b.textLines) if (rate === 0) stdout.write(clr + contentRow(b, line) + "\n");
+		else {
+			let inner = "";
+			for (const ch of line) if (Math.random() < rate) {
+				const charColor = Math.random() < .3 ? b.pal.glow : b.pal.base;
+				inner += `${charColor}${GLITCH_CHARS[Math.floor(Math.random() * 12)]}${b.pal.text}`;
+			} else inner += ch;
+			const fill = " ".repeat(b.innerWidth - 4 - line.length);
+			stdout.write(clr + pad + `${b.pal.base}│${R}  ${b.pal.text}${inner}${R}${fill}  ${b.pal.base}│${R}\n`);
+		}
+		stdout.write(clr + pad + authorRow(b) + "\n");
+		stdout.write(clr + pad + bottomBorder(b) + "\n");
+		if (f < noiseRates.length - 1) await sleep(120);
+	}
+};
+const animMatrixRain = async (b) => {
+	const width = b.innerWidth + 2;
+	const RAIN_HEIGHT = 6;
+	const streams = Array.from({ length: RAIN_HEIGHT }, () => Array(width).fill(" "));
+	const chars = "日ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘｱﾎﾏｹﾒｴｶｷﾑﾕﾗｾﾈｽﾀﾇﾍ0123456789";
+	for (let frame = 0; frame < 9; frame++) {
+		for (let y = RAIN_HEIGHT - 1; y > 0; y--) streams[y] = [...streams[y - 1]];
+		streams[0] = Array(width).fill(" ").map(() => {
+			if (Math.random() < .25) return { char: chars[Math.floor(Math.random() * 42)] };
+			return " ";
+		});
+		if (frame > 0) stdout.write(up(RAIN_HEIGHT));
+		for (let y = 0; y < RAIN_HEIGHT; y++) {
+			let line = "";
+			for (let x = 0; x < width; x++) {
+				const cell = streams[y][x];
+				if (cell === " ") line += " ";
+				else {
+					const typedCell = cell;
+					const color = y === 0 ? b.pal.glow : y <= 2 ? b.pal.text : y <= 4 ? b.pal.base : b.pal.faint;
+					line += `${color}${typedCell.char}${R}`;
+				}
+			}
+			stdout.write((frame > 0 ? CLR : "") + line + "\n");
+		}
+		await sleep(90);
+	}
+	stdout.write(up(RAIN_HEIGHT));
+	for (let y = 0; y < RAIN_HEIGHT; y++) stdout.write(CLR + "\n");
+	stdout.write(up(RAIN_HEIGHT));
+	printBox(b);
+};
+const ANIMS = [
+	animTypewriter,
+	animWaveReveal,
+	animSlide,
+	animPulseBorder,
+	animGlitch,
+	animMatrixRain
+];
+function playStartupDisplay() {
+	if (!stdout.isTTY) return Promise.resolve();
+	return (async () => {
+		try {
+			const quote = QUOTES[Math.floor(Math.random() * QUOTES.length)];
+			const pal = PALETTES[Math.floor(Math.random() * PALETTES.length)];
+			const b = makeBox(quote, pal);
+			const anim = ANIMS[Math.floor(Math.random() * ANIMS.length)];
+			stdout.write("\n" + HIDE);
+			await anim(b);
+			stdout.write(SHOW);
+		} catch {
+			try {
+				stdout.write(SHOW);
+			} catch {}
+		}
+	})();
+}
+//#endregion
 //#region src/cli.ts
 const args = process.argv.slice(2);
 if (new Set([
@@ -1823,14 +2723,16 @@ if (new Set([
 	"resolve",
 	"comments",
 	"url",
-	"mcp"
+	"mcp",
+	"plan",
+	"update"
 ]).has(args[0])) {
 	if (args[0] === "mcp") {
-		const { startMcpServer } = await import("./mcp-BQmH_By-.mjs");
+		const { startMcpServer } = await import("./mcp-CFeE13n-.mjs");
 		await startMcpServer();
 		await new Promise(() => {});
 	}
-	const { runSubcommand } = await import("./cli-agent-DZBvZoXZ.mjs");
+	const { runSubcommand } = await import("./cli-agent-BNwY5lZE.mjs");
 	process.exit(await runSubcommand(args[0], args.slice(1)));
 }
 const opts = parseDiffOptions(args);
@@ -1853,9 +2755,19 @@ if (opts.outputMode === "terminal") {
 	const exitCode = runTerminalDiff(opts);
 	process.exit(exitCode);
 }
+const __pkgDir = dirname(fileURLToPath(import.meta.url));
+const currentVersion = JSON.parse(readFileSync(resolve(__pkgDir, "..", "package.json"), "utf-8")).version;
+const updateCheckPromise = (async () => {
+	try {
+		const { checkForUpdates } = await import("./update-check-KL-2sGxE.mjs");
+		return await checkForUpdates(currentVersion);
+	} catch {
+		return null;
+	}
+})();
 const port = await getPort(opts.port ? { port: opts.port } : void 0);
 const host = opts.host;
-const clientDir = resolve(dirname(fileURLToPath(import.meta.url)), "client");
+const clientDir = resolve(__pkgDir, "client");
 const { existsSync: existsSync$1 } = await import("node:fs");
 const { port: actualPort } = await startServer({
 	port,
@@ -1871,18 +2783,24 @@ try {
 	} catch {
 		repoRoot = process.cwd();
 	}
-	const __pkgDir = dirname(fileURLToPath(import.meta.url));
-	const version = JSON.parse(readFileSync(resolve(__pkgDir, "..", "package.json"), "utf-8")).version;
 	writeServerLock({
 		port: actualPort,
 		host,
 		pid: process.pid,
 		repoRoot,
 		startedAt: Date.now(),
-		version
+		version: currentVersion
 	});
 } catch {}
 console.log(`diffing server running at ${localUrl}`);
+await playStartupDisplay();
+try {
+	const updateInfo = await updateCheckPromise;
+	if (updateInfo?.hasUpdate) {
+		const { printUpdateDisclaimer } = await import("./update-check-KL-2sGxE.mjs");
+		printUpdateDisclaimer(currentVersion, updateInfo.latestVersion);
+	}
+} catch {}
 if (!opts.noOpen) {
 	const settings = loadSettings();
 	const openUrl = `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${actualPort}`;