pi-mono-all 1.0.0

package/node_modules/pi-mono-review/index.ts

@@ -0,0 +1,8 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { registerReviewCommand } from "./review.js";
+import { registerReviewTuiCommand } from "./review-tui.js";
+
+export default function reviewExtension(pi: ExtensionAPI): void {
+	registerReviewCommand(pi);
+	registerReviewTuiCommand(pi);
+}

package/node_modules/pi-mono-review/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "pi-mono-review",
+  "version": "1.8.1",
+  "description": "Pi extension for reviewing GitHub PRs and GitLab MRs",
+  "keywords": [
+    "pi-package",
+    "pi-extension"
+  ],
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emanuelcasco/pi-mono-extensions.git",
+    "directory": "extensions/review"
+  },
+  "bugs": {
+    "url": "https://github.com/emanuelcasco/pi-mono-extensions/issues"
+  },
+  "homepage": "https://github.com/emanuelcasco/pi-mono-extensions#readme"
+}

package/node_modules/pi-mono-review/review-tui.ts

@@ -0,0 +1,194 @@
+import { BorderedLoader, type ExtensionAPI, type ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import {
+	buildReviewSession,
+	cloneSession,
+	getLatestReviewSession,
+	persistReviewSession,
+	submitReviewComments,
+	type ReviewAction,
+	type ReviewComment,
+	type ReviewResult,
+	type ReviewSession,
+} from "./common.js";
+import { ReviewerComponent } from "./reviewer.js";
+
+export function registerReviewTuiCommand(pi: ExtensionAPI): void {
+	let latestSession: ReviewSession | null = null;
+
+	function reconstructState(ctx: ExtensionContext) {
+		latestSession = getLatestReviewSession(ctx);
+	}
+
+	pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
+	pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+
+	pi.registerMessageRenderer("review-submit", (message, _options, theme) => {
+		return new Text(theme.fg("success", theme.bold("submitted ")) + message.content, 0, 0);
+	});
+
+	async function runReviewPane(ctx: ExtensionContext, session: ReviewSession): Promise<ReviewResult> {
+		const reviewSession = cloneSession(session);
+		let currentIndex = 0;
+
+		// eslint-disable-next-line no-constant-condition
+		while (true) {
+			const action = await ctx.ui.custom<ReviewAction>(
+				(tui, theme, _kb, done) => {
+					const reviewer = new ReviewerComponent(reviewSession.comments, currentIndex, theme, done);
+					return {
+						render: (w: number) => reviewer.render(w),
+						invalidate: () => reviewer.invalidate(),
+						handleInput: (data: string) => {
+							reviewer.handleInput(data);
+							tui.requestRender();
+						},
+					};
+				},
+				{
+					overlay: true,
+					overlayOptions: {
+						anchor: "right-center",
+						width: "58%",
+						minWidth: 72,
+						maxHeight: "92%",
+						margin: 1,
+					},
+				},
+			);
+
+			if (action.type === "cancel") {
+				return { session: reviewSession, approved: 0, dismissed: 0, edited: 0, cancelled: true };
+			}
+
+			if (action.type === "edit") {
+				currentIndex = action.index;
+				const comment = reviewSession.comments[action.index];
+				if (comment) {
+					const newBody = await ctx.ui.editor("Edit review comment:", comment.body);
+					if (newBody !== undefined && newBody.trim()) {
+						if (!comment.originalBody) comment.originalBody = comment.body;
+						comment.body = newBody.trim();
+						comment.status = "edited";
+					}
+				}
+				continue;
+			}
+
+			const selectedComments = reviewSession.comments.filter((c) => c.status === "approved" || c.status === "edited");
+			if (selectedComments.length === 0) {
+				ctx.ui.notify("No comments selected for submission", "warning");
+				continue;
+			}
+
+			const submission = await ctx.ui.custom<{ submitted: number; failed: string[] } | null>((tui, theme, _kb, done) => {
+				const loader = new BorderedLoader(
+					tui,
+					theme,
+					`Submitting ${selectedComments.length} comment(s) to ${reviewSession.target.platform}...`,
+				);
+				loader.onAbort = () => done(null);
+				void (async () => {
+					try {
+						done(await submitReviewComments(pi.exec.bind(pi), reviewSession.target, selectedComments, loader.signal));
+					} catch (error) {
+						ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+						done(null);
+					}
+				})();
+				return loader;
+			});
+
+			if (!submission) continue;
+
+			reviewSession.submittedAt = Date.now();
+			latestSession = reviewSession;
+			persistReviewSession(pi, reviewSession);
+			return {
+				session: reviewSession,
+				approved: reviewSession.comments.filter((c) => c.status === "approved").length,
+				dismissed: reviewSession.comments.filter((c) => c.status === "dismissed").length,
+				edited: reviewSession.comments.filter((c) => c.status === "edited").length,
+				cancelled: false,
+				submitted: submission.submitted,
+				failed: submission.failed,
+			};
+		}
+	}
+
+	pi.registerCommand("review-tui", {
+		description: "Open the latest saved review in a side pane and submit selected comments",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/review-tui requires interactive mode", "error");
+				return;
+			}
+
+			latestSession = getLatestReviewSession(ctx);
+			const url = args?.trim();
+
+			if (!latestSession && !url) {
+				ctx.ui.notify("No saved review found. Run /review <url> first, or use /review-tui <url>.", "info");
+				return;
+			}
+
+			if (url) {
+				if (!ctx.model) {
+					ctx.ui.notify("No model selected", "error");
+					return;
+				}
+				const generated = await ctx.ui.custom<ReviewSession | null>((tui, theme, _kb, done) => {
+					const loader = new BorderedLoader(tui, theme, `Reviewing ${url}...`);
+					loader.onAbort = () => done(null);
+					void (async () => {
+						try {
+							done(await buildReviewSession(pi.exec.bind(pi), ctx.model!, ctx.modelRegistry, url, loader.signal));
+						} catch (error) {
+							ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+							done(null);
+						}
+					})();
+					return loader;
+				});
+				if (!generated) return;
+				latestSession = generated;
+				persistReviewSession(pi, generated);
+			}
+
+			const session = latestSession!;
+			const cloned = cloneSession(session);
+			const prepared: ReviewSession = {
+				...cloned,
+				comments: cloned.comments.map((comment: ReviewComment) => ({
+					...comment,
+					status:
+						comment.status === "approved" || comment.status === "edited" || comment.status === "dismissed"
+							? comment.status
+							: "pending",
+				})),
+			};
+
+			const result = await runReviewPane(ctx, prepared);
+			if (result.cancelled) {
+				ctx.ui.notify("Review submission cancelled", "info");
+				return;
+			}
+
+			const failureSuffix = result.failed && result.failed.length > 0 ? ` (${result.failed.length} failed)` : "";
+			pi.sendMessage({
+				customType: "review-submit",
+				content:
+					`${result.submitted || 0} comment(s) submitted to ${result.session.target.platform}: ${result.session.target.url}` +
+					failureSuffix,
+				display: true,
+				details: result,
+			});
+
+			if (result.failed && result.failed.length > 0) {
+				ctx.ui.notify(`Submitted ${result.submitted || 0}, failed ${result.failed.length}`, "warning");
+			} else {
+				ctx.ui.notify(`Submitted ${result.submitted || 0} comment(s)`, "info");
+			}
+		},
+	});
+}

package/node_modules/pi-mono-review/review.ts

@@ -0,0 +1,119 @@
+import { BorderedLoader, type ExtensionAPI, type Theme } from "@mariozechner/pi-coding-agent";
+import { Container, Text } from "@mariozechner/pi-tui";
+import {
+	buildReviewSession,
+	getCommentBody,
+	getCommentConfidence,
+	getCommentPriority,
+	getCommentTitle,
+	getPriorityInfo,
+	persistReviewSession,
+	renderSummary,
+	type ReviewSession,
+} from "./common.js";
+
+function renderReviewSummaryMessage(session: ReviewSession | undefined, content: string, expanded: boolean, theme: Theme) {
+	if (!session) return new Text(theme.fg("accent", theme.bold("review ")) + content, 0, 0);
+
+	const container = new Container();
+	const comments = session.comments || [];
+	const counts = {
+		P0: comments.filter((comment) => getCommentPriority(comment) === "P0").length,
+		P1: comments.filter((comment) => getCommentPriority(comment) === "P1").length,
+		P2: comments.filter((comment) => getCommentPriority(comment) === "P2").length,
+		P3: comments.filter((comment) => getCommentPriority(comment) === "P3").length,
+	};
+	const countText = [`${comments.length} finding${comments.length === 1 ? "" : "s"}`]
+		.concat((Object.entries(counts) as Array<[keyof typeof counts, number]>).filter(([, count]) => count > 0).map(([priority, count]) => `${count} ${priority}`))
+		.join(", ");
+
+	container.addChild(new Text(`${theme.fg("accent", theme.bold("review "))}${theme.fg("dim", session.target.url)} ${theme.fg("muted", countText)}`, 0, 0));
+	if (session.summary) container.addChild(new Text(`  ${theme.fg("dim", session.summary)}`, 0, 0));
+
+	const displayCount = expanded ? comments.length : Math.min(3, comments.length);
+	for (let i = 0; i < displayCount; i++) {
+		const comment = comments[i]!;
+		const priority = getCommentPriority(comment);
+		const meta = getPriorityInfo(priority);
+		const end = comment.endLine && comment.endLine !== comment.line ? `-${comment.endLine}` : "";
+		container.addChild(
+			new Text(
+				`  ${theme.fg(meta.color, `${meta.symbol} [${priority}]`)} ${getCommentTitle(comment)} ${theme.fg(
+					"dim",
+					`${comment.file}:${comment.line}${end} ${(getCommentConfidence(comment) * 100).toFixed(0)}%`,
+				)}`,
+				0,
+				0,
+			),
+		);
+		if (expanded) {
+			const body = getCommentBody(comment);
+			if (body) container.addChild(new Text(`    ${theme.fg("dim", body.split("\n")[0] || "")}`, 0, 0));
+		}
+	}
+	if (comments.length > displayCount) {
+		container.addChild(new Text(theme.fg("dim", `  … ${comments.length - displayCount} more findings`), 0, 0));
+	}
+	if (comments.length > 0) container.addChild(new Text(theme.fg("dim", "  Open /review-tui to inspect, edit, toggle, and submit."), 0, 0));
+	return container;
+}
+
+export function registerReviewCommand(pi: ExtensionAPI): void {
+	pi.registerMessageRenderer<ReviewSession>("review-summary", (message, options, theme) => {
+		const content = typeof message.content === "string" ? message.content : "";
+		return renderReviewSummaryMessage(message.details, content, options.expanded, theme);
+	});
+
+	pi.registerCommand("review", {
+		description: "Review a GitHub PR or GitLab MR URL and store comments for /review-tui",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/review requires interactive mode", "error");
+				return;
+			}
+			if (!ctx.model) {
+				ctx.ui.notify("No model selected", "error");
+				return;
+			}
+
+			const url = args?.trim();
+			if (!url) {
+				ctx.ui.notify("Usage: /review <github-pr-url|gitlab-mr-url>", "warning");
+				return;
+			}
+
+			const result = await ctx.ui.custom<ReviewSession | null>((tui, theme, _kb, done) => {
+				const loader = new BorderedLoader(tui, theme, `Reviewing ${url}...`);
+				loader.onAbort = () => done(null);
+
+				void (async () => {
+					try {
+						done(await buildReviewSession(pi.exec.bind(pi), ctx.model!, ctx.modelRegistry, url, loader.signal));
+					} catch (error) {
+						ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+						done(null);
+					}
+				})();
+
+				return loader;
+			});
+
+			if (!result) return;
+
+			persistReviewSession(pi, result);
+			pi.sendMessage({
+				customType: "review-summary",
+				content: renderSummary(result),
+				display: true,
+				details: result,
+			});
+
+			ctx.ui.notify(
+				result.comments.length > 0
+					? `Review ready: ${result.comments.length} comment(s). Open /review-tui.`
+					: "Review complete: no actionable comments.",
+				"info",
+			);
+		},
+	});
+}

package/node_modules/pi-mono-review/reviewer.ts

@@ -0,0 +1,339 @@
+/**
+ * ReviewerComponent — Interactive TUI for reviewing code review comments
+ */
+
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import type { KeyId } from "@mariozechner/pi-tui";
+import {
+	getCommentBody,
+	getCommentConfidence,
+	getCommentPriority,
+	getCommentTitle,
+	getPriorityInfo,
+	type CommentStatus,
+	type ReviewAction,
+	type ReviewComment,
+} from "./common.js";
+
+function priorityLabel(comment: ReviewComment): string {
+	const priority = getCommentPriority(comment);
+	return `${getPriorityInfo(priority).symbol}  ${priority} ${(getCommentConfidence(comment) * 100).toFixed(0)}% confidence`;
+}
+
+function statusIcon(status: CommentStatus): string {
+	switch (status) {
+		case "approved":
+			return "✓";
+		case "dismissed":
+			return "✗";
+		case "edited":
+			return "✎";
+		case "pending":
+			return "○";
+	}
+}
+
+function statusColor(status: CommentStatus): "success" | "error" | "accent" | "warning" {
+	switch (status) {
+		case "approved":
+			return "success";
+		case "dismissed":
+			return "error";
+		case "edited":
+			return "accent";
+		case "pending":
+			return "warning";
+	}
+}
+
+function expandTabs(text: string): string {
+	return text.replace(/\t/g, "    ");
+}
+
+interface HunkWindow {
+	header: string | null;
+	lines: string[];
+	hiddenBefore: number;
+	hiddenAfter: number;
+}
+
+function sliceHunkAroundLines(hunk: string, targetStart: number, targetEnd: number, maxLines: number): HunkWindow {
+	const all = hunk.split("\n");
+	const headerMatch = all[0]?.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+	if (!headerMatch) {
+		return { header: null, lines: all.slice(0, maxLines), hiddenBefore: 0, hiddenAfter: Math.max(0, all.length - maxLines) };
+	}
+
+	const header = all[0]!;
+	const body = all.slice(1);
+	let newLine = Number(headerMatch[1]);
+	const lineNumbers: (number | null)[] = body.map((line) => {
+		if (line.startsWith("+") || line.startsWith(" ")) return newLine++;
+		return null;
+	});
+
+	let firstHit = -1;
+	let lastHit = -1;
+	for (let i = 0; i < body.length; i++) {
+		const n = lineNumbers[i];
+		if (n != null && n >= targetStart && n <= targetEnd) {
+			if (firstHit === -1) firstHit = i;
+			lastHit = i;
+		}
+	}
+
+	const budget = Math.max(1, maxLines - 1);
+	if (firstHit === -1) {
+		const slice = body.slice(0, budget);
+		return { header, lines: slice, hiddenBefore: 0, hiddenAfter: Math.max(0, body.length - slice.length) };
+	}
+
+	const span = lastHit - firstHit + 1;
+	let start: number;
+	let end: number;
+	if (span >= budget) {
+		start = firstHit;
+		end = firstHit + budget;
+	} else {
+		const padding = budget - span;
+		const before = Math.floor(padding / 2);
+		start = Math.max(0, firstHit - before);
+		end = Math.min(body.length, start + budget);
+		start = Math.max(0, end - budget);
+	}
+
+	return {
+		header,
+		lines: body.slice(start, end),
+		hiddenBefore: start,
+		hiddenAfter: Math.max(0, body.length - end),
+	};
+}
+
+export class ReviewerComponent {
+	private comments: ReviewComment[];
+	private currentIndex: number;
+	private theme: Theme;
+	private onDone: (action: ReviewAction) => void;
+	private cachedWidth?: number;
+	private cachedLines?: string[];
+
+	constructor(comments: ReviewComment[], startIndex: number, theme: Theme, onDone: (action: ReviewAction) => void) {
+		this.comments = comments;
+		this.currentIndex = Math.max(0, Math.min(startIndex, comments.length - 1));
+		this.theme = theme;
+		this.onDone = onDone;
+	}
+
+	handleInput(data: string): void {
+		if (this.comments.length === 0) {
+			if (matchesKey(data, Key.escape) || data === "q") this.onDone({ type: "cancel" });
+			return;
+		}
+
+		const comment = this.comments[this.currentIndex]!;
+		if (matchesKey(data, Key.up) || matchesKey(data, Key.ctrl("k"))) {
+			if (this.currentIndex > 0) {
+				this.currentIndex--;
+				this.invalidate();
+			}
+			return;
+		}
+		if (matchesKey(data, Key.down) || matchesKey(data, Key.ctrl("j"))) {
+			if (this.currentIndex < this.comments.length - 1) {
+				this.currentIndex++;
+				this.invalidate();
+			}
+			return;
+		}
+		if (data === "[") {
+			for (let i = this.currentIndex - 1; i >= 0; i--) {
+				if (this.comments[i]!.file !== comment.file) {
+					this.currentIndex = i;
+					this.invalidate();
+					return;
+				}
+			}
+			return;
+		}
+		if (data === "]") {
+			for (let i = this.currentIndex + 1; i < this.comments.length; i++) {
+				if (this.comments[i]!.file !== comment.file) {
+					this.currentIndex = i;
+					this.invalidate();
+					return;
+				}
+			}
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("a"))) {
+			comment.status = comment.status === "approved" ? "pending" : "approved";
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("d"))) {
+			comment.status = comment.status === "dismissed" ? "pending" : "dismissed";
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("e")) || matchesKey(data, Key.enter)) {
+			this.onDone({ type: "edit", index: this.currentIndex });
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("p"))) {
+			for (const c of this.comments) if (c.status === "pending") c.status = "approved";
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("s"))) {
+			this.onDone({ type: "submit" });
+			return;
+		}
+		if (matchesKey(data, Key.escape) || data === "q") {
+			this.onDone({ type: "cancel" });
+		}
+	}
+
+	render(width: number): string[] {
+		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+		const th = this.theme;
+		const lines: string[] = [];
+		const maxW = Math.max(40, Math.min(width, 120));
+		const innerW = Math.max(20, maxW - 2);
+
+		const row = (content = "") => {
+			// The TUI renderer validates terminal-visible width after the terminal expands tabs.
+			// Keep every custom-rendered row bounded by normalizing tabs before measuring/padding.
+			const normalized = expandTabs(content);
+			const fitted = visibleWidth(normalized) > innerW ? truncateToWidth(normalized, innerW) : normalized;
+			const padding = Math.max(0, innerW - visibleWidth(fitted));
+			lines.push(th.fg("border", "│") + fitted + " ".repeat(padding) + th.fg("border", "│"));
+		};
+
+		const addWrapped = (content: string, prefix = "") => {
+			const normalizedPrefix = expandTabs(prefix);
+			const available = Math.max(8, innerW - visibleWidth(normalizedPrefix));
+			for (const part of wrapTextWithAnsi(expandTabs(content), available)) {
+				row(normalizedPrefix + part);
+			}
+		};
+
+		const divider = () => row(th.fg("dim", "─".repeat(innerW)));
+		const top = () => lines.push(th.fg("border", `╭${"─".repeat(innerW)}╮`));
+		const bottom = () => lines.push(th.fg("border", `╰${"─".repeat(innerW)}╯`));
+
+		const approved = this.comments.filter((c) => c.status === "approved" || c.status === "edited").length;
+		const dismissed = this.comments.filter((c) => c.status === "dismissed").length;
+		const pending = this.comments.filter((c) => c.status === "pending").length;
+
+		top();
+		row(
+			th.fg("accent", th.bold(" Code Review ")) +
+				th.fg("muted", ` ${this.currentIndex + 1}/${this.comments.length} `) +
+				th.fg("dim", "│ ") +
+				[th.fg("success", `✓${approved}`), th.fg("error", `✗${dismissed}`), th.fg("warning", `○${pending}`)].join(
+					th.fg("dim", " │ "),
+				),
+		);
+		divider();
+
+		if (this.comments.length === 0) {
+			row("");
+			addWrapped(th.fg("dim", "No comments to review"), "  ");
+			row("");
+			addWrapped(th.fg("dim", "Esc/q close"), "  ");
+			bottom();
+			this.cachedLines = lines;
+			this.cachedWidth = width;
+			return lines;
+		}
+
+		const comment = this.comments[this.currentIndex]!;
+		row("");
+		const lineInfo = comment.endLine
+			? `${th.fg("warning", String(comment.line))}${th.fg("dim", "-")}${th.fg("warning", String(comment.endLine))}`
+			: th.fg("warning", String(comment.line));
+		addWrapped(`${th.fg("accent", comment.file)}${th.fg("dim", ":")}${lineInfo}`, "  ");
+		row("");
+
+		if (comment.codeContext) {
+			const targetStart = Math.min(comment.line, comment.endLine ?? comment.line);
+			const targetEnd = Math.max(comment.line, comment.endLine ?? comment.line);
+			const window = sliceHunkAroundLines(comment.codeContext, targetStart, targetEnd, 12);
+			const linePrefix = `  ${th.fg("dim", "┃")} `;
+			if (window.header) addWrapped(th.fg("dim", window.header), linePrefix);
+			if (window.hiddenBefore > 0) {
+				addWrapped(th.fg("dim", `... ${window.hiddenBefore} earlier line${window.hiddenBefore !== 1 ? "s" : ""}`), linePrefix);
+			}
+			for (const cl of window.lines) {
+				const styled = cl.startsWith("+")
+					? th.fg("toolDiffAdded", cl)
+					: cl.startsWith("-")
+						? th.fg("toolDiffRemoved", cl)
+						: th.fg("toolDiffContext", cl);
+				addWrapped(styled, linePrefix);
+			}
+			if (window.hiddenAfter > 0) {
+				addWrapped(th.fg("dim", `... ${window.hiddenAfter} later line${window.hiddenAfter !== 1 ? "s" : ""}`), linePrefix);
+			}
+			row("");
+		}
+
+		const priority = getCommentPriority(comment);
+		addWrapped(th.fg(getPriorityInfo(priority).color, priorityLabel(comment)), "  ");
+		divider();
+		row("");
+		addWrapped(th.fg("text", th.bold(getCommentTitle(comment))), "  ");
+		row("");
+		const bodyLines = getCommentBody(comment).split("\n");
+		for (const bl of bodyLines.slice(0, 20)) addWrapped(th.fg("text", bl), "  ");
+		if (bodyLines.length > 20) addWrapped(th.fg("dim", `... ${bodyLines.length - 20} more lines`), "  ");
+		if (comment.status === "edited" && comment.originalBody) {
+			row("");
+			addWrapped(th.fg("dim", "original: " + comment.originalBody), "  ");
+		}
+		row("");
+		addWrapped(th.fg(statusColor(comment.status), `${statusIcon(comment.status)} ${comment.status.charAt(0).toUpperCase() + comment.status.slice(1)}`), "  ");
+		divider();
+		row("");
+
+		const maxDots = 40;
+		let dotsSlice = this.comments;
+		let dotsOffset = 0;
+		let prefixEllipsis = false;
+		let suffixEllipsis = false;
+		if (this.comments.length > maxDots) {
+			const half = Math.floor(maxDots / 2);
+			let start = Math.max(0, this.currentIndex - half);
+			let end = start + maxDots;
+			if (end > this.comments.length) {
+				end = this.comments.length;
+				start = Math.max(0, end - maxDots);
+			}
+			dotsSlice = this.comments.slice(start, end);
+			dotsOffset = start;
+			prefixEllipsis = start > 0;
+			suffixEllipsis = end < this.comments.length;
+		}
+		const dots = dotsSlice
+			.map((c, i) => {
+				const idx = dotsOffset + i;
+				return th.fg(idx === this.currentIndex ? "accent" : statusColor(c.status), idx === this.currentIndex ? "●" : statusIcon(c.status));
+			})
+			.join(" ");
+		addWrapped(`${prefixEllipsis ? th.fg("dim", "… ") : ""}${dots}${suffixEllipsis ? th.fg("dim", " …") : ""}`, "  ");
+		row("");
+		addWrapped(th.fg("dim", "↑↓/^j^k navigate  [/] prev/next file  ^a approve  ^d dismiss  ^e/Enter edit"), "  ");
+		addWrapped(th.fg("dim", "^p approve pending  ^s submit  Esc/q cancel"), "  ");
+		bottom();
+		this.cachedLines = lines;
+		this.cachedWidth = width;
+		return lines;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}