@gavin-hu/my-pi-agent 0.12.0 → 0.13.1

package/extensions/plan/index.ts

@@ -21,7 +21,10 @@ import { Key } from "@earendil-works/pi-tui";
 import { fileURLToPath } from "node:url";
 import { hasPathInput } from "./path-guard.ts";
 import { isExtensionEnabled } from "../../lib/env.ts";
+import { sanitizeLine } from "../../lib/format.ts";
+import { lastGoal, type PublishedGoal } from "../../lib/goal-state.ts";
 import { ASK_USER_QUESTION_TOOL, SUBAGENT_READ_ONLY_PARAM, SUBAGENT_TOOL } from "../../lib/tool-names.ts";
+import { clip } from "../../lib/tui/columns.ts";
 import { STATUS_KEYS } from "../../lib/tui/glyphs.ts";
 import { planModeNotice, registerCommands } from "./commands.ts";
 import { checkReadOnlyGit } from "./git-bash.ts";
@@ -39,15 +42,34 @@ import { createPlanWebReview } from "./web.ts";
 /** Marker embedded in the injected prompt and used to filter stale context. */
 export const PLAN_MODE_MARKER = "[PLAN MODE ACTIVE]";
 
-/** Injected each turn while planning: the facts and the next action, not the tool contracts. */
-export const PLAN_MODE_CONTEXT = `${PLAN_MODE_MARKER}
-You are in plan mode: read-only exploration for safe code analysis.
+/**
+ * Longest goal text restated here. `goal` injects the full objective every turn
+ * regardless of plan mode, so this line is a short pointer; the clip is what keeps
+ * the whole context inside the prompt-budget ceiling.
+ */
+const GOAL_CONTEXT_CHARS = 64;
 
-- Do not modify anything except the plan file: while planning, ${READ_ONLY_SUMMARY}.
-- bash is git-only: read-only commands (git status, git diff, git log) may be chained with && or ;, but pipes, substitution, and redirection are blocked and powershell is unavailable. The cwd is already the project root, so do not prefix commands with cd; use read, grep, find, and ls for files.
-- Investigate and design a concrete plan, then save it with write_plan and call exit_plan_mode with the returned plan_path for approval.
-- Delegate broad exploration with subagent; while planning it is forced read-only.
-- To choose between approaches, ask with ${ASK_USER_QUESTION_TOOL} before finalizing.`;
+/**
+ * Injected each turn while planning: the facts and the next action, not the tool
+ * contracts. An active session goal becomes one extra bullet, so a plan is
+ * designed against the objective instead of beside it.
+ */
+export function planModeContext(goal?: PublishedGoal | null): string {
+	const lines = [
+		PLAN_MODE_MARKER,
+		"You are in plan mode: read-only exploration for safe code analysis.",
+		"",
+		`- Do not modify anything except the plan file: while planning, ${READ_ONLY_SUMMARY}.`,
+		"- bash is git-only: read-only commands (git status, git diff, git log) may be chained with && or ;, but pipes, substitution, and redirection are blocked and powershell is unavailable. The cwd is already the project root, so do not prefix commands with cd; use read, grep, find, and ls for files.",
+		"- Investigate and design a concrete plan, then save it with write_plan and call exit_plan_mode with the returned plan_path for approval.",
+		"- Delegate broad exploration with subagent; while planning it is forced read-only.",
+		`- To choose between approaches, ask with ${ASK_USER_QUESTION_TOOL} before finalizing.`,
+	];
+	if (goal?.status === "active") {
+		lines.push(`- Current session goal: ${clip(sanitizeLine(goal.objective), GOAL_CONTEXT_CHARS)}`);
+	}
+	return lines.join("\n");
+}
 
 /** This extension entry file, as Pi records it for our tool registrations. */
 function extensionEntryPath(): string | undefined {
@@ -158,10 +180,12 @@ export default function planMode(pi: ExtensionAPI): void {
 		return reason ? { block: true, reason } : undefined;
 	});
 
-	// Tell the model it is planning.
-	pi.on("before_agent_start", () => {
+	// Tell the model it is planning, and restate an active goal so the plan is
+	// designed against it. Reads the branch, so no extra model call is involved.
+	pi.on("before_agent_start", (_event, ctx) => {
 		if (!runtime.isEnabled()) return undefined;
-		return { message: { customType: "plan-mode-context", content: PLAN_MODE_CONTEXT, display: false } };
+		const goal = lastGoal(ctx.sessionManager.getBranch());
+		return { message: { customType: "plan-mode-context", content: planModeContext(goal), display: false } };
 	});
 
 	// Keep stale plan-mode context out of later, non-plan turns (for example after /resume).

package/extensions/plan/plan-index.ts

@@ -0,0 +1,234 @@
+/**
+ * The `/plan list` surface: the plan index as a notice, and as a docked list
+ * screen.
+ *
+ * A plan is a file, and the plans directory is its only index, so this module
+ * presents what `PlanStore.index` walked: the title, the modified time, and how
+ * far its steps got, newest first. Enter on the screen hands the focused plan
+ * back to the caller, which reuses the browser review; every other mode gets the
+ * same facts as one line per plan, with the path to reopen.
+ *
+ * Derived state only: the summaries are passed in, a reload replaces them, and a
+ * render reads them — like the `/memory` picker.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Key, matchesKey, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import { sanitizeLine, shortenPath } from "../../lib/format.ts";
+import { fitRows, formatRange, isCloseKey, ListCursor, navigateList, scrollList } from "../../lib/tui/cursor.ts";
+import { dockListFrame, screenHint, type ViewportRowsSource } from "../../lib/tui/chrome.ts";
+import { clip } from "../../lib/tui/columns.ts";
+import { emptyState, listRow } from "../../lib/tui/rows.ts";
+import { titleRule } from "../../lib/tui/rules.ts";
+import { paint } from "../../lib/tui/tokens.ts";
+import type { PlanSummary } from "./plans.ts";
+
+/** Rows the screen shows when the terminal height is unknown. */
+const DEFAULT_ROWS = 14;
+/** Fixed rows around the list: header, summary, blank, range, detail, hint, blank. */
+const CHROME = 7;
+/** Longest title a row draws before the trailing meta wins the column. */
+const TITLE_WIDTH = 56;
+
+/**
+ * How long ago a plan was modified: `today`, `3d ago`, `2mo ago`, `1y ago`.
+ * Coarse on purpose — a list row compares plans, it does not time them.
+ */
+export function relativeAge(modifiedMs: number, nowMs: number): string {
+	const days = Math.floor(Math.max(0, nowMs - modifiedMs) / 86_400_000);
+	if (days < 1) return "today";
+	if (days < 30) return `${days}d ago`;
+	const months = Math.floor(days / 30);
+	if (months < 12) return `${months}mo ago`;
+	return `${Math.floor(days / 365)}y ago`;
+}
+
+/** `3/7 steps`, `2/2 steps`, or `steps unknown` for a file the store would not have written. */
+function stepsText(summary: PlanSummary): string {
+	if (!summary.steps) return "steps unknown";
+	return `${summary.steps.done}/${summary.steps.total} steps`;
+}
+
+/** Local `YYYY-MM-DD HH:mm`, matching the stamp the file name carries. */
+function localTime(ms: number): string {
+	const date = new Date(ms);
+	const pad = (value: number): string => String(value).padStart(2, "0");
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+/**
+ * The non-TUI listing: one line per plan with its title, step progress, modified
+ * time, and path, newest first. The directory is named once in the header.
+ */
+export function formatPlanIndex(summaries: readonly PlanSummary[], dir: string): string {
+	const where = sanitizeLine(shortenPath(dir));
+	if (summaries.length === 0) {
+		return `No plans in ${where} yet; write_plan saves one there.`;
+	}
+	const lines = summaries.map(
+		(summary) =>
+			`  ${sanitizeLine(summary.title)} — ${stepsText(summary)} — ${localTime(summary.modified)} — ${sanitizeLine(summary.relativePath)}`,
+	);
+	return [`Plans (${summaries.length}) — ${where}`, ...lines].join("\n");
+}
+
+export interface PlanIndexOptions {
+	summaries: readonly PlanSummary[];
+	/** Directory the plans live in, for the header. */
+	dir: string;
+	theme: Theme;
+	/** Enter on the focused plan; the caller opens its review after the screen closes. */
+	onSelect: (summary: PlanSummary) => void;
+	onClose: () => void;
+	/** `r`: re-read the directory. Resolves with the new rows. */
+	reload: () => Promise<readonly PlanSummary[]>;
+	requestRender: () => void;
+	viewportRows?: ViewportRowsSource;
+	/** Clock for the relative ages; defaults to the wall clock. */
+	now?: () => number;
+}
+
+/** Docked `/plan list` screen: the plans directory, newest first. */
+export class PlanIndexComponent implements Component {
+	private readonly cursor: ListCursor;
+	private summaries: readonly PlanSummary[];
+	private notice: string | undefined;
+	private componentFocused = false;
+
+	constructor(private readonly options: PlanIndexOptions) {
+		this.summaries = options.summaries;
+		this.cursor = new ListCursor(() => options.requestRender());
+		// A screen can take its first key before it is drawn; keep the cursor valid.
+		this.cursor.sync(this.summaries.length);
+	}
+
+	/** Replace the rows after a reload, keeping the focused plan if it is still there. */
+	private setSummaries(next: readonly PlanSummary[]): void {
+		this.summaries = next;
+		this.cursor.sync(next.length);
+		this.cursor.selected = Math.min(this.cursor.selected, Math.max(0, next.length - 1));
+		this.requestRender();
+	}
+
+	private requestRender(): void {
+		this.options.requestRender();
+	}
+
+	private reload(): void {
+		void this.options
+			.reload()
+			.then((next) => {
+				this.setSummaries(next);
+				this.notice = next.length === 0 ? "No plans yet." : undefined;
+			})
+			.catch((error: unknown) => {
+				this.notice = `Could not read the plans directory: ${error instanceof Error ? error.message : String(error)}`;
+				this.requestRender();
+			});
+	}
+
+	handleInput(data: string): void {
+		if (isCloseKey(data) || data === "q") {
+			this.options.onClose();
+			return;
+		}
+		if (this.notice !== undefined) this.notice = undefined;
+
+		if (navigateList(data, this.cursor, this.summaries.length)) {
+			this.requestRender();
+			return;
+		}
+		// The hint advertises `g`/`G`, so bind them to the ends.
+		if (data === "g" || data === "G") {
+			this.cursor.set(data === "g" ? 0 : this.summaries.length - 1, this.summaries.length);
+			this.requestRender();
+			return;
+		}
+		if (data === "r") {
+			this.reload();
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			const focused = this.summaries[this.cursor.selected];
+			if (focused) this.options.onSelect(focused);
+		}
+	}
+
+	/** Wheel scrolling moves the selection, matching the other list screens. */
+	handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+		return scrollList(event, this.cursor, this.summaries.length);
+	}
+
+	/** Rows are built per render from the current theme and summaries; nothing is memoized. */
+	invalidate(): void {}
+
+	get focused(): boolean {
+		return this.componentFocused;
+	}
+
+	set focused(value: boolean) {
+		this.componentFocused = value;
+	}
+
+	private row(summary: PlanSummary, selected: boolean, width: number): string {
+		const now = (this.options.now ?? Date.now)();
+		const trailing = `${stepsText(summary)} · ${relativeAge(summary.modified, now)}`;
+		return listRow(this.options.theme, width, {
+			selected,
+			label: clip(sanitizeLine(summary.title), TITLE_WIDTH),
+			labelRole: selected ? "accent" : "label",
+			trailing,
+			trailingRole: "meta",
+		});
+	}
+
+	private summaryLine(width: number): string {
+		const { theme } = this.options;
+		const count = this.summaries.length;
+		const text = `${paint(theme, "accent", "Plans")} ${paint(theme, "meta", `· ${count} ${count === 1 ? "plan" : "plans"}`)}`;
+		const where = paint(theme, "faint", ` · ${sanitizeLine(shortenPath(this.options.dir))}`);
+		return clip(`  ${text}${where}`, width);
+	}
+
+	private detailLines(width: number): string[] {
+		const focused = this.summaries[this.cursor.selected];
+		if (!focused) return [];
+		const { theme } = this.options;
+		const path = paint(theme, "meta", sanitizeLine(focused.relativePath));
+		const time = paint(theme, "faint", ` · modified ${localTime(focused.modified)}`);
+		return [clip(`  ${path}${time}`, width)];
+	}
+
+	render(width: number): string[] {
+		const { theme } = this.options;
+		const w = Math.max(1, width);
+		this.cursor.visible = fitRows(this.options.viewportRows, this.summaries.length, CHROME, DEFAULT_ROWS);
+		this.cursor.sync(this.summaries.length);
+
+		const body: string[] = [];
+		if (this.summaries.length === 0) {
+			body.push(...emptyState(theme, w, { label: "No plans yet. write_plan saves one under .pi/plans." }));
+		} else {
+			const { start, end } = this.cursor.window(this.summaries.length);
+			for (let index = start; index < end; index++) {
+				body.push(this.row(this.summaries[index], index === this.cursor.selected, w));
+			}
+		}
+
+		const hint =
+			this.notice !== undefined
+				? clip(`  ${paint(theme, "meta", this.notice)}`, w)
+				: screenHint(theme, w, ["Esc close", { text: "Enter review", color: "accent" }, "r reload", "↑/↓", "g/G"]);
+
+		return dockListFrame({
+			header: titleRule(theme, w, "Plan index"),
+			summary: this.summaryLine(w),
+			body,
+			range: this.cursor.clipped(this.summaries.length)
+				? formatRange(theme, w, { ...this.cursor.window(this.summaries.length), total: this.summaries.length })
+				: undefined,
+			detail: this.detailLines(w),
+			hint,
+		});
+	}
+}

package/extensions/plan/plan-text.ts

@@ -0,0 +1,95 @@
+/**
+ * The plan text as a review shows and compares it (pure).
+ *
+ * Two needs pull in the same direction. A plan is model-authored text, so it is
+ * neutralized before it reaches a terminal or a page; and a review has to compare
+ * what it shows against what the previous review showed. Both start from the same
+ * normalization — control characters stripped, tabs expanded, stored feedback
+ * removed — so the digest a review writes and the digest a later review compares
+ * cannot disagree about a plan that did not change.
+ *
+ * The baseline is one digest per heading section rather than the previous plan
+ * text, so it can live in a session entry without copying the plan file into the
+ * branch on every review.
+ */
+
+import { createHash } from "node:crypto";
+import { stripControlChars } from "../../lib/format.ts";
+import { stripFeedback } from "./feedback.ts";
+import { extractPlanSections } from "./steps.ts";
+
+/** Spaces a tab expands to; the terminal's own tab stops are not width-modelled. */
+const TAB_WIDTH = 4;
+
+/** One heading section's identity and content digest. */
+export interface SectionDigest {
+	/** Plain heading text, or `""` for the content before the first heading. */
+	title: string;
+	/** SHA-256 of the section's normalized text, heading included. */
+	digest: string;
+}
+
+/**
+ * Replace control characters (including ESC and the C1 block) and expand tabs
+ * so model-authored plan text cannot drive the terminal. Newlines are kept, so
+ * callers can still render or split the text line by line.
+ */
+export function sanitizePlanText(text: string): string {
+	return stripControlChars(text.replace(/\t/g, " ".repeat(TAB_WIDTH)));
+}
+
+/**
+ * The text a review compares: terminal-safe, with tabs expanded and stored
+ * feedback removed. A review comment a browser wrote into the file is a note to
+ * the model, not an edit, so it never reads as a changed section.
+ */
+export function reviewText(content: string): string {
+	return stripFeedback(sanitizePlanText(content));
+}
+
+/** Digest one section's text; the heading line is part of it. */
+function digestOf(text: string): string {
+	return createHash("sha256").update(text.trim()).digest("hex");
+}
+
+/** One digest per heading section, in document order, for a persisted baseline. */
+export function sectionDigests(content: string): SectionDigest[] {
+	return extractPlanSections(reviewText(content)).map((section) => ({
+		title: section.title,
+		digest: digestOf(section.text),
+	}));
+}
+
+/** Whether two baselines describe the same content, section for section. */
+export function sameSections(a: readonly SectionDigest[], b: readonly SectionDigest[]): boolean {
+	if (a.length !== b.length) return false;
+	return a.every((section, index) => section.title === b[index].title && section.digest === b[index].digest);
+}
+
+/**
+ * Per-section change flags for a second review: `boolean[]` aligned with
+ * `extractPlanSections(reviewText(current))`, so duplicate headings are flagged
+ * by occurrence rather than by title. An absent baseline flags nothing, which is
+ * what a first review of a plan looks like; `stripFeedback` only ever drops
+ * quote-marker lines, so the flags stay aligned with the sections a screen
+ * renders from the same content.
+ */
+export function changedSections(baseline: readonly SectionDigest[] | undefined, current: string): boolean[] {
+	const sections = extractPlanSections(reviewText(current));
+	if (baseline === undefined) return sections.map(() => false);
+
+	const before = new Map<string, string[]>();
+	for (const section of baseline) {
+		const digests = before.get(section.title);
+		if (digests) digests.push(section.digest);
+		else before.set(section.title, [section.digest]);
+	}
+
+	const seen = new Map<string, number>();
+	return sections.map((section) => {
+		const index = seen.get(section.title) ?? 0;
+		seen.set(section.title, index + 1);
+		const prior = before.get(section.title)?.[index];
+		return prior === undefined || prior !== digestOf(section.text);
+	});
+}

package/extensions/plan/plans.ts

@@ -23,12 +23,14 @@ import {
 	readFileSync,
 	readdirSync,
 	renameSync,
+	statSync,
 	unlinkSync,
 	writeFileSync,
 } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { CONFIG_DIR_NAME, getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { repoRootFor } from "../../lib/git/index.ts";
+import { sanitizeLine } from "../../lib/format.ts";
 import { isInside, isInsideReal } from "../../lib/path.ts";
 import { formatFeedback, type PlanAnnotation } from "./feedback.ts";
 import { extractPlanSteps, matchesStepText, setStepStatuses, type StepUpdate } from "./steps.ts";
@@ -53,6 +55,23 @@ export interface WrittenPlan extends StoredPlan {
 	title: string;
 }
 
+/** One row of the plan index: enough to choose a plan without opening it. */
+export interface PlanSummary {
+	/** Absolute path. */
+	path: string;
+	/** Path relative to the working directory, when it is inside it. */
+	relativePath: string;
+	/** The plan's `# title`, or a title derived from the file name. */
+	title: string;
+	/** File modification time, ms since the epoch. */
+	modified: number;
+	bytes: number;
+	/** Steps done and total, or undefined for a file the store would not have written. */
+	steps?: { done: number; total: number };
+	/** True when the file is over {@link MAX_PLAN_BYTES} and was listed without a read. */
+	oversize?: boolean;
+}
+
 export interface WritePlanInput {
 	/** Short title; drives the file-name slug. */
 	title: string;
@@ -70,6 +89,11 @@ export interface PlanStore {
 	read(cwd: string, planPath: string): Promise<StoredPlan | undefined>;
 	/** The newest plan file in the plans directory, or undefined when there is none. */
 	latest(cwd: string): Promise<StoredPlan | undefined>;
+	/**
+	 * Every plan in the directory, newest first. The directory is the index, so
+	 * this is one `readdir`, one `stat` per file, and one bounded read per plan.
+	 */
+	index(cwd: string): Promise<PlanSummary[]>;
 	/** Set the given top-level steps' checkboxes in an existing plan. Throws when the file or any step is invalid. */
 	setSteps(cwd: string, planPath: string, updates: StepUpdate[]): Promise<StoredPlan>;
 	/** Replace the plan's stored browser feedback. Throws when the file is missing or outside the plans directory. */
@@ -342,5 +366,70 @@ export function createPlanStore(pi: ExtensionAPI, options: { now?: () => Date }
 		return newest ? read(cwd, newest.path) : undefined;
 	};
 
-	return { dirFor, write, read, latest, setSteps, saveFeedback };
+	/**
+	 * Every plan in the directory, newest first: the directory is the index.
+	 *
+	 * One `readdir`, one `lstat`/`stat` per entry, and one `readFileSync` per plan
+	 * that fits {@link MAX_PLAN_BYTES}. A larger file is listed as `oversize`
+	 * without being read — the store would never have written it, and pulling it
+	 * into memory to print one row is not worth the risk. A symlinked entry, a
+	 * dotfile, or a file that vanishes mid-walk is simply not a plan.
+	 */
+	const index = async (cwd: string): Promise<PlanSummary[]> => {
+		const dir = await dirFor(cwd);
+		let names: string[];
+		try {
+			names = readdirSync(dir);
+		} catch {
+			return [];
+		}
+
+		const summaries: PlanSummary[] = [];
+		for (const name of names) {
+			const path = join(dir, name);
+			if (!isPlanFileName(path)) continue;
+			let info: ReturnType<typeof statSync>;
+			try {
+				// lstat, not stat: a symlink is never a plan.
+				info = lstatSync(path);
+			} catch {
+				continue;
+			}
+			if (!info.isFile()) continue;
+			if (!isContainedPlan(dir, path)) continue;
+
+			const summary: PlanSummary = {
+				path,
+				relativePath: relativeTo(cwd, path),
+				title: planTitle(name),
+				modified: info.mtimeMs,
+				bytes: info.size,
+			};
+			if (info.size > MAX_PLAN_BYTES) {
+				summaries.push({ ...summary, oversize: true });
+				continue;
+			}
+			try {
+				const content = readFileSync(path, "utf-8");
+				const heading = /^ {0,3}#\s+(.+)$/m.exec(content)?.[1];
+				const title = heading === undefined ? "" : sanitizeLine(heading).trim();
+				const steps = extractPlanSteps(content);
+				summaries.push({
+					...summary,
+					...(title ? { title } : {}),
+					steps: { done: steps.filter((step) => step.status === "completed").length, total: steps.length },
+				});
+			} catch {
+				// An unreadable plan is still a file the user may want to see; list the
+				// row from its name and leave the content-derived fields out.
+				summaries.push(summary);
+			}
+		}
+		// Newest first, with the name (which carries the stamp) as the tie break —
+		// the same order `latest` picks from.
+		summaries.sort((a, b) => b.modified - a.modified || (a.path < b.path ? 1 : a.path > b.path ? -1 : 0));
+		return summaries;
+	};
+
+	return { dirFor, write, read, latest, index, setSteps, saveFeedback };
 }

package/extensions/plan/review.ts

@@ -18,6 +18,7 @@ import { askHuman } from "../../lib/interaction.ts";
 import { FULL_SCREEN_OVERLAY } from "../../lib/tui/chrome.ts";
 import { feedbackSummary, type PlanAnnotation } from "./feedback.ts";
 import type { PlanStore, StoredPlan } from "./plans.ts";
+import type { SectionDigest } from "./plan-text.ts";
 import { extractPlanSteps } from "./steps.ts";
 import { PlanViewComponent, type PlanViewAction } from "./tui.ts";
 import type { PlanReviewResult, PlanReviewSession, PlanWebReview } from "./web.ts";
@@ -47,7 +48,9 @@ export type ReviewDecision =
 
 /** What the previous review showed, so this one can mark what changed. */
 export interface ReviewBaselines {
-	reviewed(path: string): string | undefined;
+	/** The sections the last review of `path` showed, when this branch has one. */
+	reviewed(path: string): SectionDigest[] | undefined;
+	/** Remember what a review just showed, as a session entry on this branch. */
 	markReviewed(path: string, content: string): void;
 }
 
@@ -106,7 +109,7 @@ function planReviewDigest(content: string): string {
 async function askPlanReview(
 	ctx: ExtensionToolContext,
 	plan: StoredPlan,
-	previous: string | undefined,
+	baseline: SectionDigest[] | undefined,
 ): Promise<PlanReviewChoice> {
 	let sentFullText = false;
 	for (;;) {
@@ -116,7 +119,7 @@ async function askPlanReview(
 					(tui, theme, _keybindings, done) =>
 						new PlanViewComponent({
 							plan,
-							previous,
+							baseline,
 							theme,
 							onClose: (action, refinement) => done({ action, refinement }),
 							requestRender: () => tui.requestRender(),
@@ -156,8 +159,8 @@ async function askPlanReview(
 export interface BrowserReviewOptions {
 	/** Whether the browser may approve the plan (only the `exit_plan_mode` flow). */
 	canApprove: boolean;
-	/** The content the previous review showed, so the page can mark changed sections. */
-	previous?: string;
+	/** The section digests the previous review showed, for the changed markers. */
+	baseline?: SectionDigest[];
 	/** Aborting the turn closes the session as cancelled. */
 	signal?: AbortSignal;
 	/** Called once the server is listening and the browser was opened. */
@@ -176,7 +179,7 @@ export async function runBrowserReview(
 ): Promise<PlanReviewResult | undefined> {
 	if (options.signal?.aborted) return { status: "cancelled" };
 	const session = await web
-		.start(cwd, plan, { canApprove: options.canApprove, previous: options.previous, signal: options.signal })
+		.start(cwd, plan, { canApprove: options.canApprove, baseline: options.baseline, signal: options.signal })
 		.catch(() => undefined);
 	if (!session) return undefined;
 	options.onOpened?.(session);
@@ -200,8 +203,8 @@ export async function reviewPlan(options: ReviewPlanOptions): Promise<ReviewDeci
 		if (signal?.aborted) return { action: "keep", plan };
 		// Read the baseline before the screen and mark it after, so what the next
 		// review compares against is the content this one actually showed.
-		const previous = baselines.reviewed(plan.path);
-		const choice = await askPlanReview(ctx, plan, previous);
+		const baseline = baselines.reviewed(plan.path);
+		const choice = await askPlanReview(ctx, plan, baseline);
 		baselines.markReviewed(plan.path, plan.content);
 
 		if (choice.action === "approve") return { action: "approve", plan, comments: [] };
@@ -218,7 +221,7 @@ export async function reviewPlan(options: ReviewPlanOptions): Promise<ReviewDeci
 
 		const result = await runBrowserReview(web, ctx.cwd, plan, {
 			canApprove: true,
-			previous,
+			baseline,
 			signal,
 			onOpened: (session) => ctx.ui.notify(`Plan review: opened ${session.url}`, "info"),
 		});