@gavin-hu/my-pi-agent 0.18.0 → 0.19.0

package/extensions/plan/blocks.ts

@@ -14,7 +14,7 @@
  * step.
  */
 
-import { FENCE, HEADING } from "./steps.ts";
+import { FENCE, HEADING } from "./sections.ts";
 
 /** How a block is rendered and grouped. */
 export type PlanBlockKind = "heading" | "paragraph" | "list" | "code" | "quote" | "table" | "hr" | "blank";
@@ -176,7 +176,7 @@ export function planBlocks(plan: string): PlanBlock[] {
 }
 
 /** The block containing source line `line`, or the nearest block before it. */
-export function blockAt(blocks: PlanBlock[], line: number): PlanBlock | undefined {
+export function blockAt(blocks: readonly PlanBlock[], line: number): PlanBlock | undefined {
 	let candidate: PlanBlock | undefined;
 	for (const block of blocks) {
 		if (block.start <= line && line <= block.end) return block;
@@ -186,6 +186,27 @@ export function blockAt(blocks: PlanBlock[], line: number): PlanBlock | undefine
 	return candidate;
 }
 
+/**
+ * The nearest block with content at or before `line`, else the first one after
+ * it: what a comment in blank space belongs to.
+ *
+ * A blank line is a block, so {@link blockAt} may name one, but a comment cannot
+ * hang on nothing: the review page renders no line for a blank block, so an
+ * anchor there is one it can never attach a thread to.
+ */
+export function contentBlockAt(blocks: readonly PlanBlock[], line: number): PlanBlock | undefined {
+	let before: PlanBlock | undefined;
+	for (const block of blocks) {
+		const content = block.kind !== "blank";
+		if (block.start <= line) {
+			if (content) before = block;
+			continue;
+		}
+		if (content) return before ?? block;
+	}
+	return before;
+}
+
 /** The source inside a fenced code block, without its opening and closing fence lines. */
 export function codeBody(block: PlanBlock): string[] {
 	if (block.kind !== "code") return block.lines.slice();

package/extensions/plan/commands.ts

@@ -13,6 +13,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { isRemoteTurn } from "../../lib/interaction.ts";
 import { READ_ONLY_SUMMARY } from "../../lib/plan-entry.ts";
 import { qrLines } from "../../lib/qr.ts";
+import { withRailsSuppressed } from "../../lib/rails.ts";
 import { feedbackSummary } from "./feedback.ts";
 import { PlanIndexComponent, formatPlanIndex } from "./plan-index.ts";
 import { runBrowserReview } from "./review.ts";
@@ -192,22 +193,26 @@ async function openPlanIndex(
 
 	// 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;
-	});
+	// A dock list shares the editor slot with the goal and todo rails, so it takes
+	// the dock to itself for as long as it is open, like the other list screens.
+	await withRailsSuppressed(pi, () =>
+		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);
 }
 

package/extensions/plan/feedback.ts

@@ -21,8 +21,8 @@
  */
 
 import { sanitizeLine } from "../../lib/format.ts";
-import { blockAt, planBlocks, type PlanBlock } from "./blocks.ts";
-import { extractPlanSections } from "./steps.ts";
+import { blockAt, contentBlockAt, planBlocks, type PlanBlock } from "./blocks.ts";
+import { extractSections, sectionKeys } from "./sections.ts";
 
 /** Marker that opens every stored feedback line. */
 export const REVIEW_MARKER = "[!REVIEW]";
@@ -191,19 +191,43 @@ export function stripFeedback(plan: string): string {
 }
 
 /**
- * Read stored feedback back. The anchor is the block ending just before each
- * marker in the stripped plan, so a comment keeps its place across reloads.
+ * A plan read the way the review reads it: its body, its blocks, and its
+ * comments, out of one parse.
  */
-export function parseFeedback(plan: string): PlanAnnotation[] {
+export interface FeedbackRead {
+	/** The plan body with every stored marker removed. */
+	body: string;
+	/** The body split into source-line blocks: the shape an anchor names. */
+	blocks: PlanBlock[];
+	/** The comments the markers carried, each anchored to a content block's start. */
+	annotations: PlanAnnotation[];
+}
+
+/**
+ * Read a plan once. An anchor is the start of the block the marker follows, so a
+ * comment keeps its place across reloads — and it is always a block with
+ * content, because the page renders no line for a blank one and so can never
+ * attach a thread to it. A plan whose every line is blank has no such block: its
+ * comments keep anchor `0` and the page lists them as unattached, which is the
+ * truth there.
+ */
+export function readFeedback(plan: string): FeedbackRead {
 	const { clean, markers } = scanMarkers(plan);
-	if (markers.length === 0) return [];
 	const blocks = planBlocks(clean);
-	return markers.map((marker) => {
-		const block = blockAt(blocks, marker.at);
-		const annotation: PlanAnnotation = { anchor: block ? block.start : 0, comment: marker.comment };
+	const annotations = markers.map((marker) => {
+		const annotation: PlanAnnotation = {
+			anchor: contentBlockAt(blocks, marker.at)?.start ?? 0,
+			comment: marker.comment,
+		};
 		if (marker.author) annotation.author = marker.author;
 		return annotation;
 	});
+	return { body: clean, blocks, annotations };
+}
+
+/** The comments a plan carries, in the order they were written. */
+export function parseFeedback(plan: string): PlanAnnotation[] {
+	return readFeedback(plan).annotations;
 }
 
 /** Sanitized, non-empty comments with the anchor they land on. */
@@ -230,7 +254,9 @@ export function formatFeedback(plan: string, annotations: PlanAnnotation[], opti
 		.map((marker) => ({ at: marker.at, line: markerLine(marker.author, marker.comment) }));
 	const blocks = planBlocks(clean);
 	const added = storableComments(annotations).map((item) => ({
-		at: blockAt(blocks, item.anchor)?.end ?? -1,
+		// A marker beside a block, never after a blank line: an anchor that names
+		// blank space is written where the page can read it back as a thread.
+		at: contentBlockAt(blocks, item.anchor)?.end ?? -1,
 		line: markerLine(author, item.comment),
 	}));
 	return compose(clean, [...kept, ...added]);
@@ -247,30 +273,92 @@ function blockKey(block: PlanBlock): string {
 }
 
 /**
- * A plan's heading sections, keyed by title and occurrence, each with the blocks
- * inside it and its last source line. Two `## Notes` sections are told apart by
- * which one they are, the way `changedSections` does it, so a duplicate heading
- * never collects both sections' blocks.
+ * Words a block is compared by when it may merely have been reworded: lowercased,
+ * with the list marker and task checkbox dropped. Every step of a `## Steps`
+ * section would otherwise match every other one through its `- [ ]` alone.
+ */
+function blockWords(block: PlanBlock): Set<string> {
+	const text = block.lines
+		.join(" ")
+		.toLowerCase()
+		.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, " ")
+		.replace(/\[[ x]\]/g, " ");
+	return new Set(text.split(/[^\p{L}\p{N}]+/u).filter((word) => word !== ""));
+}
+
+/** Share of the longer block's words that both blocks have. */
+function sharedShare(a: ReadonlySet<string>, b: ReadonlySet<string>): number {
+	if (a.size === 0 || b.size === 0) return 0;
+	let shared = 0;
+	for (const word of a) if (b.has(word)) shared += 1;
+	return shared / Math.max(a.size, b.size);
+}
+
+/** Share of its words a block keeps, at or above which it is the same block reworded. */
+const MATCH_SHARE = 0.5;
+
+/**
+ * Which block of `next` each block of `old` became, keeping both lists in
+ * document order: the longest set of pairs whose wording overlaps enough to be one
+ * block reworded. A block left without a pair is `-1` — deleted, or replaced by
+ * text that shares nothing — which is the gap its comment belongs in.
+ */
+function alignBlocks(old: readonly PlanBlock[], next: readonly PlanBlock[]): number[] {
+	const before = old.map(blockWords);
+	const after = next.map(blockWords);
+	const matches = before.map((words) => after.map((other) => (sharedShare(words, other) >= MATCH_SHARE ? 1 : 0)));
+	// A longest common subsequence over the match grid, so a block that moved keeps
+	// its own pairing instead of pulling the blocks around it along.
+	const width = next.length + 1;
+	const counts = new Array<number>((old.length + 1) * width).fill(0);
+	for (let row = old.length - 1; row >= 0; row--) {
+		for (let column = next.length - 1; column >= 0; column--) {
+			const paired = matches[row][column] === 1 ? 1 + counts[(row + 1) * width + column + 1] : 0;
+			counts[row * width + column] = Math.max(
+				paired,
+				counts[(row + 1) * width + column],
+				counts[row * width + column + 1],
+			);
+		}
+	}
+	const aligned = new Array<number>(old.length).fill(-1);
+	let row = 0;
+	let column = 0;
+	while (row < old.length && column < next.length) {
+		if (matches[row][column] === 1 && counts[row * width + column] === 1 + counts[(row + 1) * width + column + 1]) {
+			aligned[row] = column;
+			row += 1;
+			column += 1;
+			continue;
+		}
+		if (counts[(row + 1) * width + column] >= counts[row * width + column + 1]) row += 1;
+		else column += 1;
+	}
+	return aligned;
+}
+
+/**
+ * A plan's heading sections, keyed by `sectionKeys`, each with the blocks a
+ * comment can hang on and the last line of that content. Blank lines are left out
+ * on purpose: a position among them would move when one is added or removed
+ * above, and a reworded step would lose its comment to the next block. A section
+ * with no content block ends at its own heading, which the page renders.
  */
 function sectionIndex(plan: string, blocks: readonly PlanBlock[]): Map<string, { blocks: PlanBlock[]; end: number }> {
-	const sections = extractPlanSections(plan);
-	const lineCount = plan === "" ? 0 : plan.split("\n").length;
-	const seen = new Map<string, number>();
+	const sections = extractSections(plan);
 	const index = new Map<string, { blocks: PlanBlock[]; end: number }>();
-	const keys = sections.map((section, position) => {
-		const occurrence = seen.get(section.title) ?? 0;
-		seen.set(section.title, occurrence + 1);
-		const key = `${occurrence}\u0000${section.title}`;
-		index.set(key, { blocks: [], end: (sections[position + 1]?.line ?? lineCount) - 1 });
-		return key;
-	});
+	const keys = sectionKeys(sections);
+	keys.forEach((key, at) => index.set(key, { blocks: [], end: sections[at]?.line ?? 0 }));
 
 	let position = 0;
 	for (const block of blocks) {
 		while (position + 1 < sections.length && (sections[position + 1]?.line ?? 0) <= block.start) position += 1;
 		const key = keys[position];
 		if (key === undefined) continue;
-		index.get(key)?.blocks.push(block);
+		const entry = index.get(key);
+		if (!entry || block.kind === "blank") continue;
+		entry.blocks.push(block);
+		entry.end = block.end;
 	}
 	return index;
 }
@@ -280,9 +368,11 @@ function sectionIndex(plan: string, blocks: readonly PlanBlock[]): Map<string, {
  * Comments are not plan content, so `next` is stripped of any marker it carries,
  * and every old one is re-attached by the strongest evidence that survives: the
  * block's text (per occurrence, so two identical steps keep their own comments),
- * then the same section and ordinal, then the end of that section. A comment
- * whose section is gone too is placed at the end rather than dropped, where the
- * review page shows it as unattached.
+ * then the block the alignment says it became when the wording changed, then the
+ * gap it left between the blocks that survived, then the end of that section's
+ * content. A comment whose section is gone too moves to the plan's last content
+ * block, so the page keeps showing it under a block rather than listing it as
+ * unattached; only a plan with no block at all leaves it in that list.
  */
 export function carryFeedback(previous: string, next: string): string {
 	const { clean: oldClean, markers } = scanMarkers(previous);
@@ -303,16 +393,35 @@ export function carryFeedback(previous: string, next: string): string {
 	const oldSections = sectionIndex(oldClean, oldBlocks);
 	const nextSections = sectionIndex(cleanNext, nextBlocks);
 	const lastLine = cleanNext === "" ? -1 : cleanNext.split("\n").length - 1;
+	// Where a comment goes when nothing about it survived: beside the plan's last
+	// block, never after the blank line a trailing newline leaves.
+	const tail = contentBlockAt(nextBlocks, lastLine)?.end ?? lastLine;
+
+	/** One alignment per section, reused by every comment that lands in it. */
+	const alignments = new Map<string, number[]>();
 
-	/** The block at the same ordinal in the same section, else that section's end. */
+	/**
+	 * Where a comment goes when its own block's text is gone: the block the alignment
+	 * says it became, else the gap it left, else its section's end.
+	 */
 	const bySection = (block: PlanBlock): number | undefined => {
-		for (const [key, old] of oldSections) {
-			const ordinal = old.blocks.indexOf(block);
-			if (ordinal < 0) continue;
-			const section = nextSections.get(key);
-			if (section === undefined) return undefined;
-			const same = section.blocks[ordinal];
-			return same ? same.end : section.end;
+		for (const [key, before] of oldSections) {
+			const index = before.blocks.indexOf(block);
+			if (index < 0) continue;
+			const after = nextSections.get(key);
+			if (after === undefined) return undefined;
+			let aligned = alignments.get(key);
+			if (aligned === undefined) {
+				aligned = alignBlocks(before.blocks, after.blocks);
+				alignments.set(key, aligned);
+			}
+			const became = aligned[index];
+			if (became >= 0) return after.blocks[became].end;
+			// The gap it left is right after the block before its nearest surviving
+			// successor: for the first block of a section, that is the heading.
+			const successor = aligned.findIndex((at, from) => from > index && at >= 0);
+			const gap = successor >= 0 ? after.blocks[aligned[successor] - 1] : undefined;
+			return gap?.end ?? after.end;
 		}
 		return undefined;
 	};
@@ -320,12 +429,12 @@ export function carryFeedback(previous: string, next: string): string {
 	const placed = markers.map((marker) => {
 		const block = blockAt(oldBlocks, marker.at);
 		const line = markerLine(marker.author, marker.comment);
-		if (block === undefined) return { at: lastLine, line };
+		if (block === undefined) return { at: tail, line };
 		if (block.kind !== "blank") {
 			const match = queues.get(blockKey(block))?.shift();
 			if (match !== undefined) return { at: match.end, line };
 		}
-		return { at: bySection(block) ?? lastLine, line };
+		return { at: bySection(block) ?? tail, line };
 	});
 	return compose(cleanNext, placed);
 }

package/extensions/plan/index.ts

@@ -149,10 +149,12 @@ export default function planMode(pi: ExtensionAPI): void {
 	 * the path backstop (a hint on a path-carrying tool is only a claim).
 	 */
 	const blockedReason = (toolName: string, input: unknown): string | undefined => {
-		// Plan-owned control tools are the sanctioned exception: `write_plan` saves
-		// the artifact, `exit_plan_mode` presents it. The source-path check keeps a
-		// same-named tool from another extension from borrowing the exemption.
-		if (runtime.isControlTool(toolName)) return undefined;
+		// Plan-owned tools are the sanctioned exception: `write_plan` saves the
+		// artifact, `exit_plan_mode` presents it, `cancel_plan_mode` restores access,
+		// and `enter_plan_mode` answers "already" to a call that was in flight when
+		// plan mode came on. The source-path check keeps a same-named tool from
+		// another extension from borrowing the exemption.
+		if (runtime.isOwnTool(toolName)) return undefined;
 		// `subagent` stays active, but only as read-only delegation. The flag is
 		// forced in place (the child enforces it through `--tools`), so the model
 		// cannot forget it; a `subagent` that does not declare the parameter is

package/extensions/plan/plan-index.ts

@@ -16,7 +16,8 @@ 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 { detailBlockRows, dockListFrame, screenHint, type ViewportRowsSource } from "../../lib/tui/chrome.ts";
+import { formatSize } from "../../lib/format.ts";
 import { clip } from "../../lib/tui/columns.ts";
 import { emptyState, listRow } from "../../lib/tui/rows.ts";
 import { titleRule } from "../../lib/tui/rules.ts";
@@ -25,8 +26,12 @@ 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, closing rule. */
-const CHROME = 7;
+/**
+ * Fixed rows around the list body: header, summary, blank, and the closing footer
+ * (blank, hint, rule). The focused path adds `detailBlockRows` on top, and `fitRows`
+ * adds one more when the range row appears.
+ */
+const CHROME = 6;
 /** Longest title a row draws before the trailing meta wins the column. */
 const TITLE_WIDTH = 56;
 
@@ -56,11 +61,33 @@ function localTime(ms: number): string {
 	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
 }
 
+/**
+ * The store's own footprint for one repository: the bytes its plans hold, and the
+ * oldest of them. Derived from the summary the directory walk already produced, so
+ * reporting a size never becomes a second index that can disagree with the files.
+ */
+function footprint(summaries: readonly PlanSummary[]): { bytes: number; oldest: number } {
+	let bytes = 0;
+	let oldest = summaries[0]?.modified ?? 0;
+	for (const summary of summaries) {
+		bytes += summary.bytes;
+		oldest = Math.min(oldest, summary.modified);
+	}
+	return { bytes, oldest };
+}
+
+/** `2.4 kB — oldest 2d ago`, the store's footprint as the header and the screen say it. */
+function footprintText(summaries: readonly PlanSummary[], nowMs: number): string {
+	const { bytes, oldest } = footprint(summaries);
+	return `${formatSize(bytes)} — oldest ${relativeAge(oldest, nowMs)}`;
+}
+
 /**
  * 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.
+ * time, and path, newest first. The header names the count, the store's footprint,
+ * and the directory once; `now` is injectable so the age can be asserted.
  */
-export function formatPlanIndex(summaries: readonly PlanSummary[], dir: string): string {
+export function formatPlanIndex(summaries: readonly PlanSummary[], dir: string, now: number = Date.now()): string {
 	const where = sanitizeLine(shortenPath(dir));
 	if (summaries.length === 0) {
 		return `No plans in ${where} yet; write_plan saves one there.`;
@@ -69,7 +96,7 @@ export function formatPlanIndex(summaries: readonly PlanSummary[], dir: string):
 		(summary) =>
 			`  ${sanitizeLine(summary.title)} — ${stepsText(summary)} — ${localTime(summary.modified)} — ${sanitizeLine(summary.relativePath)}`,
 	);
-	return [`Plans (${summaries.length}) — ${where}`, ...lines].join("\n");
+	return [`Plans (${summaries.length}) — ${footprintText(summaries, now)} — ${where}`, ...lines].join("\n");
 }
 
 export interface PlanIndexOptions {
@@ -185,7 +212,8 @@ export class PlanIndexComponent implements Component {
 	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 size = footprintText(this.summaries, (this.options.now ?? Date.now)());
+		const text = `${paint(theme, "accent", "Plans")} ${paint(theme, "meta", `· ${count} ${count === 1 ? "plan" : "plans"} · ${size}`)}`;
 		const where = paint(theme, "faint", ` · ${sanitizeLine(shortenPath(this.options.dir))}`);
 		return clip(`  ${text}${where}`, width);
 	}
@@ -202,8 +230,14 @@ export class PlanIndexComponent implements Component {
 	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 detail = this.detailLines(w);
+		this.cursor.visible = fitRows(
+			this.options.viewportRows,
+			this.summaries.length,
+			CHROME + detailBlockRows(detail),
+			DEFAULT_ROWS,
+		);
 
 		const body: string[] = [];
 		if (this.summaries.length === 0) {
@@ -229,7 +263,7 @@ export class PlanIndexComponent implements Component {
 			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),
+			detail,
 			hint,
 		});
 	}

package/extensions/plan/plan-text.ts

@@ -16,7 +16,7 @@
 import { createHash } from "node:crypto";
 import { stripControlChars } from "../../lib/format.ts";
 import { displayFeedback, stripFeedback } from "./feedback.ts";
-import { extractPlanSections } from "./steps.ts";
+import { extractSections, sectionKeys, type PlanSection } from "./sections.ts";
 
 /** Spaces a tab expands to; the terminal's own tab stops are not width-modelled. */
 const TAB_WIDTH = 4;
@@ -71,7 +71,7 @@ export function planDigest(text: string): string {
 
 /** One digest per heading section, in document order, for a persisted baseline. */
 export function sectionDigests(content: string): SectionDigest[] {
-	return extractPlanSections(reviewText(content)).map((section) => ({
+	return extractSections(reviewText(content)).map((section) => ({
 		title: section.title,
 		digest: digestOf(section.text),
 	}));
@@ -83,30 +83,40 @@ export function sameSections(a: readonly SectionDigest[], b: readonly SectionDig
 	return a.every((section, index) => section.title === b[index].title && section.digest === b[index].digest);
 }
 
+/** One section of the text as it reads now, and whether it differs from the baseline. */
+export interface SectionMark {
+	/** The section, in the order the document lists it. */
+	section: PlanSection;
+	/** Whether its content differs from the baseline's section in the same place. */
+	changed: boolean;
+}
+
 /**
- * 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.
+ * Per-section change marks for a second review: every section of `current` with
+ * whether its content differs from the baseline's section in the same place.
+ *
+ * The marks carry their sections, so a caller cannot pair the flags with a list it
+ * parsed separately — the section list and its marks come out of one scan, in
+ * document order. Duplicate headings are told apart by occurrence rather than by
+ * title. An absent baseline marks nothing, which is what a first review of a plan
+ * looks like; `stripFeedback` only ever drops quote-marker lines, so the marks 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);
+export function changedSections(baseline: readonly SectionDigest[] | undefined, current: string): SectionMark[] {
+	const sections = extractSections(reviewText(current));
+	if (baseline === undefined) return sections.map((section) => ({ section, changed: 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]);
-	}
+	// Same section across two reviews: `sectionKeys` tells a second `## Notes` from
+	// the first, so a duplicate heading is never compared with the wrong digest.
+	const before = new Map<string, string>();
+	sectionKeys(baseline).forEach((key, at) => {
+		const digest = baseline[at]?.digest;
+		if (digest !== undefined) before.set(key, 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);
+	const keys = sectionKeys(sections);
+	return sections.map((section, at) => {
+		const prior = before.get(keys[at] ?? "");
+		return { section, changed: prior === undefined || prior !== digestOf(section.text) };
 	});
 }

package/extensions/plan/plans.ts

@@ -40,7 +40,6 @@ import { CONFIG_DIR_NAME, getAgentDir, type ExtensionAPI } from "@earendil-works
 import { resolveEffectiveCwd } from "../../lib/env.ts";
 import { sanitizeLine, shortenPath } from "../../lib/format.ts";
 import { isInside, isInsideReal } from "../../lib/path.ts";
-import { plansDir } from "../../lib/plans/store.ts";
 import { repoKeyFor } from "../../lib/repo-key.ts";
 import { carryFeedback, formatFeedback, normalizeAuthor, type PlanAnnotation } from "./feedback.ts";
 import { extractPlanSteps, matchesStepText, setStepStatuses, type StepUpdate } from "./steps.ts";
@@ -49,6 +48,13 @@ import { extractPlanSteps, matchesStepText, setStepStatuses, type StepUpdate } f
 export const MAX_PLAN_BYTES = 256 * 1024;
 /** Longest slug derived from a plan title. */
 const MAX_SLUG_LENGTH = 60;
+/** The agent-directory entry plans are filed under. */
+const PLANS_DIRNAME = "plans";
+
+/** The plan store: `<agent-dir>/plans`, or `<agent-dir>/plans/<key>` inside a repository. */
+function plansDir(agentDir: string, key?: string): string {
+	return key === undefined ? join(agentDir, PLANS_DIRNAME) : join(agentDir, PLANS_DIRNAME, key);
+}
 
 /** A plan read from disk. */
 export interface StoredPlan {
@@ -94,13 +100,6 @@ export interface WritePlanInput {
 export interface PlanStore {
 	/** Directory plans are written to for `cwd`. */
 	dirFor(cwd: string): Promise<string>;
-	/**
-	 * The repository root `cwd` belongs to, or undefined outside a repository.
-	 *
-	 * A repository-scoped setting — the split switch — is read at the root, so a
-	 * session started in a subdirectory still sees what the project turned on.
-	 */
-	rootFor(cwd: string): Promise<string | undefined>;
 	write(cwd: string, input: WritePlanInput): Promise<WrittenPlan>;
 	/** Read a plan inside the plans directory, or undefined when missing/outside. */
 	read(cwd: string, planPath: string): Promise<StoredPlan | undefined>;
@@ -330,8 +329,6 @@ export function createPlanStore(pi: ExtensionAPI, options: { now?: () => Date }
 
 	const dirFor = async (cwd: string): Promise<string> => (await resolve(cwd)).dir;
 
-	const rootFor = async (cwd: string): Promise<string | undefined> => (await resolve(cwd)).root;
-
 	const write = async (cwd: string, input: WritePlanInput): Promise<WrittenPlan> => {
 		const base = baseOf(cwd);
 		const title = input.title.trim();
@@ -556,5 +553,5 @@ export function createPlanStore(pi: ExtensionAPI, options: { now?: () => Date }
 		return summaries;
 	};
 
-	return { dirFor, rootFor, write, read, latest, index, setSteps, saveFeedback, takeNotice };
+	return { dirFor, write, read, latest, index, setSteps, saveFeedback, takeNotice };
 }