@gavin-hu/my-pi-agent 0.11.4 → 0.13.0

package/extensions/plan/commands.ts

@@ -2,21 +2,26 @@
  * Slash command for the plan-mode extension.
  *
  * `/plan` toggles plan mode, or enters it and sends an optional task;
- * `Ctrl+Alt+P` toggles too. `/plan review [path]` is the one reserved
- * subcommand: it opens the plan in the browser, and when the user saves their
- * comments sends them to the model as a refinement request.
+ * `Ctrl+Alt+P` toggles too. Two subcommands are reserved: `/plan review [path]`
+ * opens a plan in the browser (and sends saved comments to the model as a
+ * refinement), and `/plan list` shows the plans directory, newest first, with
+ * Enter opening a review.
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isRemoteTurn } from "../../lib/interaction.ts";
 import { feedbackSummary } from "./feedback.ts";
+import { PlanIndexComponent, formatPlanIndex } from "./plan-index.ts";
 import { READ_ONLY_SUMMARY } from "./policy.ts";
+import { runBrowserReview } from "./review.ts";
 import type { PlanRuntime } from "./runtime.ts";
+import type { PlanSummary } from "./plans.ts";
 import { createPlanWebReview, type PlanWebReview } from "./web.ts";
 
 const ENABLED_NOTICE = `Plan mode enabled — ${READ_ONLY_SUMMARY}.`;
 const DISABLED_NOTICE = "Plan mode disabled — full access restored.";
 const REVIEW_PREFIX = "review";
+const LIST_PREFIX = "list";
 
 /** Notice text for the current mode; shared by `/plan` and the `Ctrl+Alt+P` shortcut. */
 export function planModeNotice(enabled: boolean): string {
@@ -29,6 +34,14 @@ function reviewTarget(args: string): string | undefined {
 	return target === "" ? undefined : target;
 }
 
+/**
+ * Whether a command line is the reserved `list` subcommand. Exact match only, so
+ * `list the untracked files` stays a task instead of silently listing plans.
+ */
+function isListSubcommand(prompt: string): boolean {
+	return prompt.toLowerCase() === LIST_PREFIX;
+}
+
 /**
  * Whether a command line is the reserved `review` subcommand. Bare `review`
  * always is; a path after it is, but `review the auth flow` stays a task, so a
@@ -57,34 +70,39 @@ async function reviewInBrowser(
 	// to the newest plan file in the plans directory.
 	const file = path ? await runtime.plans.read(ctx.cwd, path) : await runtime.plans.latest(ctx.cwd);
 	if (!file) {
-		if (path) ctx.ui.notify(`plan review: no plan file at ${path}`, "error");
-		else ctx.ui.notify("plan review: no plan to review; write one with write_plan or pass a path.", "warning");
+		if (path) ctx.ui.notify(`Plan review: no plan file at ${path}`, "error");
+		else ctx.ui.notify("Plan review: no plan to review; write one with write_plan or pass a path.", "warning");
 		return;
 	}
 	// The server is loopback-only, so a remote turn cannot drive it.
 	if (isRemoteTurn(ctx)) {
-		ctx.ui.notify("plan review: browser review needs the local machine.", "warning");
+		ctx.ui.notify("Plan review: browser review needs the local machine.", "warning");
 		return;
 	}
 
-	const previous = runtime.reviewed(file.path);
-	runtime.markReviewed(file.path, file.content);
-	const session = await web.start(ctx.cwd, file, { previous }).catch(() => undefined);
-	if (!session) {
-		ctx.ui.notify("plan review: could not start the browser review server.", "error");
+	const baseline = runtime.reviewed(file.path);
+	const result = await runBrowserReview(web, ctx.cwd, file, {
+		canApprove: false,
+		baseline,
+		// Mark only once the page is actually open: a failed start must not consume
+		// the baseline for a plan nobody saw.
+		onOpened: (session) => {
+			runtime.markReviewed(file.path, file.content);
+			ctx.ui.notify(`Plan review: opened ${session.url}`, "info");
+		},
+	});
+	if (!result) {
+		ctx.ui.notify("Plan review: could not start the browser review server.", "error");
 		return;
 	}
-	ctx.ui.notify(`plan review: opened ${session.url}`, "info");
-	const result = await session.done;
-	await session.close();
 
 	if (result.status === "cancelled") {
-		ctx.ui.notify("plan review: closed without saving.", "info");
+		ctx.ui.notify("Plan review: closed without saving.", "info");
 		return;
 	}
 	const summary = feedbackSummary(result.annotations);
 	if (!summary) {
-		ctx.ui.notify("plan review: saved with no comments.", "info");
+		ctx.ui.notify("Plan review: saved with no comments.", "info");
 		return;
 	}
 	const message = runtime.isEnabled()
@@ -94,6 +112,47 @@ async function reviewInBrowser(
 	else await pi.sendUserMessage(message, { deliverAs: "followUp" });
 }
 
+/**
+ * `/plan list`: show the plans directory, newest first. The TUI gets a docked
+ * list whose Enter opens the focused plan's review; every other mode gets the
+ * same facts as a notice, with each plan's path.
+ */
+async function openPlanIndex(
+	pi: ExtensionAPI,
+	runtime: PlanRuntime,
+	web: PlanWebReview,
+	ctx: ExtensionContext,
+): Promise<void> {
+	const dir = await runtime.plans.dirFor(ctx.cwd);
+	const summarise = async (): Promise<Awaited<ReturnType<typeof runtime.plans.index>>> => runtime.plans.index(ctx.cwd);
+	const summaries = await summarise();
+
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify(formatPlanIndex(summaries, dir), "info");
+		return;
+	}
+
+	// The review runs after the screen closes, so the input focus is free again.
+	let selected: (PlanSummary | undefined) | undefined;
+	await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+		const component = new PlanIndexComponent({
+			summaries,
+			dir,
+			theme,
+			onSelect: (summary) => {
+				selected = summary;
+				done();
+			},
+			onClose: () => done(),
+			reload: summarise,
+			requestRender: () => tui.requestRender(),
+			viewportRows: () => tui.terminal?.rows,
+		});
+		return component;
+	});
+	if (selected) await reviewInBrowser(pi, runtime, web, selected.path, ctx);
+}
+
 export function registerCommands(
 	pi: ExtensionAPI,
 	runtime: PlanRuntime,
@@ -101,16 +160,22 @@ export function registerCommands(
 ): void {
 	pi.registerCommand("plan", {
 		description:
-			"Toggle plan mode (read-only exploration), enter it with an optional task, or review a plan in the browser",
+			"Toggle plan mode (read-only exploration), enter it with an optional task, list saved plans, or review one in the browser",
 		getArgumentCompletions: (prefix) => {
 			const text = prefix.trimStart();
 			if (text.includes(" ")) return null;
-			return REVIEW_PREFIX.startsWith(text) ? [{ value: REVIEW_PREFIX, label: REVIEW_PREFIX }] : null;
+			const subcommands = [LIST_PREFIX, REVIEW_PREFIX].filter((name) => name.startsWith(text));
+			return subcommands.length > 0 ? subcommands.map((value) => ({ value, label: value })) : null;
 		},
 		handler: async (args, ctx) => {
 			const prompt = args.trim();
 
-			// `/plan review [path]` is a reserved subcommand; everything else is a task.
+			// `/plan list` and `/plan review [path]` are reserved subcommands;
+			// everything else is a task.
+			if (isListSubcommand(prompt)) {
+				await openPlanIndex(pi, runtime, web, ctx);
+				return;
+			}
 			if (isReviewSubcommand(prompt)) {
 				await reviewInBrowser(pi, runtime, web, reviewTarget(prompt), ctx);
 				return;

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);
+	});
+}