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

package/extensions/plan/sections.ts

@@ -0,0 +1,112 @@
+/**
+ * Plan-document sections (pure).
+ *
+ * One fence-aware scan of a plan's markdown: the review screen navigates by
+ * section, `set_plan_steps` looks up `## Steps`, a carried comment finds the
+ * block it belongs to, and the browser outline lists the same headings. A second
+ * scanner would disagree about a heading inside a fence, so every reader goes
+ * through this module.
+ *
+ * The scan is deliberately smaller than CommonMark: a heading is up to three
+ * leading spaces, a space after the hashes, and an optional closing run; a fence
+ * is three backticks or tildes anywhere a fence may start. Inside a fence
+ * nothing is a heading, which is what keeps a `# comment` in a shell example out
+ * of the outline. Every section keeps its raw source lines, so a caller can edit
+ * exactly what it read.
+ */
+
+/** A heading-delimited chunk of a plan, for navigation and in-place edits. */
+export interface PlanSection {
+	/** Plain heading text, or `""` for the content before the first heading. */
+	title: string;
+	/** The section's markdown, including its heading line. */
+	text: string;
+	/** 0-based source line of the section's heading (0 for the preamble). */
+	line: number;
+	/** Heading level, or 0 for the preamble before the first heading. */
+	level: number;
+}
+
+/**
+ * A markdown heading outside a fence, capturing its level and text: up to three
+ * leading spaces, a space after the hashes, and a closing hash run only when a
+ * space separates it. Shared with the block model, so the section split and the
+ * browser outline read a heading line the same way, and `## C#` keeps its title.
+ */
+export const HEADING = /^ {0,3}(#{1,6})\s+(.*?)(?:\s+#+)?\s*$/;
+
+/**
+ * A markdown code-fence opener or closer (backticks or tildes). Shared with the
+ * block model: a tab-indented fence is prose for both parsers, never code for one
+ * and prose for the other.
+ */
+export const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+
+/**
+ * A heading or step label as the review surfaces compare it: inline emphasis and
+ * code removed, whitespace collapsed. Exported so a renderer labels an outline
+ * entry the same way {@link extractSections} labels its section, which is what
+ * lets the browser mark a changed section.
+ */
+export function normalizeHeadingText(text: string): string {
+	return text
+		.replace(/\*\*([^*]+)\*\*/g, "$1")
+		.replace(/\*([^*]+)\*/g, "$1")
+		.replace(/(?<![A-Za-z0-9_])_([^_]+)_(?![A-Za-z0-9_])/g, "$1")
+		.replace(/`([^`]+)`/g, "$1")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+/**
+ * Sections of a plan, split at heading lines outside code fences. The content
+ * before the first heading is a section titled `""`. Pi's `Markdown` renderer
+ * exposes no source-line map, so the review screen renders these chunks
+ * separately to know where each section begins.
+ */
+export function extractSections(plan: string): PlanSection[] {
+	const sections: PlanSection[] = [];
+	let current: PlanSection | undefined;
+	let fence: string | undefined;
+
+	const flush = (): void => {
+		if (current && (current.title !== "" || current.text.trim() !== "")) sections.push(current);
+		current = undefined;
+	};
+
+	plan.split("\n").forEach((line, index) => {
+		const fenceMatch = line.match(FENCE);
+		if (fenceMatch) {
+			if (fence === undefined) fence = fenceMatch[1][0];
+			else if (fence === fenceMatch[1][0]) fence = undefined;
+		} else if (fence === undefined) {
+			const heading = line.match(HEADING);
+			if (heading) {
+				flush();
+				current = { title: normalizeHeadingText(heading[2]), text: line, line: index, level: heading[1].length };
+				return;
+			}
+		}
+		if (current === undefined) current = { title: "", text: line, line: 0, level: 0 };
+		else current.text += `\n${line}`;
+	});
+
+	flush();
+	return sections;
+}
+
+/**
+ * One key per section that tells two identically titled headings apart: the title
+ * and which occurrence of it this is, in document order. The review pairs a
+ * baseline digest with the section it belongs to by it, and the feedback codec
+ * matches a comment's section across a rewrite, so a second `## Notes` never
+ * collects the first one's lines.
+ */
+export function sectionKeys(sections: readonly { title: string }[]): string[] {
+	const seen = new Map<string, number>();
+	return sections.map((section) => {
+		const occurrence = seen.get(section.title) ?? 0;
+		seen.set(section.title, occurrence + 1);
+		return `${occurrence}\u0000${section.title}`;
+	});
+}

package/extensions/plan/steps.ts

@@ -18,26 +18,7 @@
  * checkbox or a `[DONE:n]` marker sets the status.
  */
 
-import {
-	extractSections as extractPlanSections,
-	FENCE,
-	HEADING,
-	normalizeHeadingText,
-} from "../../lib/plans/sections.ts";
-
-/**
- * The section machinery is `lib/plans/sections.ts`, because the split writes
- * `## Team` with the same fence-aware scan this module navigates with. These
- * re-exports keep the plan extension's public surface one import.
- */
-export {
-	extractSections as extractPlanSections,
-	FENCE,
-	HEADING,
-	normalizeHeadingText,
-	replaceSection,
-} from "../../lib/plans/sections.ts";
-export type { PlanSection } from "../../lib/plans/sections.ts";
+import { extractSections, FENCE, HEADING, normalizeHeadingText } from "./sections.ts";
 
 /** Most steps seeded from one plan. */
 export const MAX_STEPS = 50;
@@ -295,7 +276,7 @@ const LIST_PREFIX = /^\s*(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s*)?/;
  */
 export function verificationItem(plan: string): PlanStep | undefined {
 	if (stepsSection(plan) === undefined) return undefined;
-	const section = extractPlanSections(plan).find(
+	const section = extractSections(plan).find(
 		(candidate) => candidate.level > 0 && candidate.title.toLowerCase() === "verification",
 	);
 	if (!section) return undefined;
@@ -394,7 +375,7 @@ export function setStepStatuses(plan: string, updates: readonly StepEdit[]): str
  * `## Goal` section, so the caller can fall back to the title.
  */
 export function goalSection(plan: string): string | undefined {
-	const section = extractPlanSections(plan).find(
+	const section = extractSections(plan).find(
 		(candidate) => candidate.level === 2 && normalizeHeadingText(candidate.title).toLowerCase() === "goal",
 	);
 	if (section === undefined) return undefined;

package/extensions/plan/todos.ts

@@ -22,6 +22,16 @@ export interface TodoMerge {
 	skipped: number;
 	/** Existing items kept as they were. */
 	kept: number;
+	/**
+	 * Untouched items dropped because they were seeded by an earlier approval of this
+	 * plan and are no longer one of its steps: the plan was renamed or rewritten.
+	 */
+	replaced: number;
+	/**
+	 * Older seeds kept because someone had already started or finished them. Deleting one
+	 * would erase work a reader did, so they are reported instead of replaced.
+	 */
+	stale: number;
 	/** Plan steps left out because the list reached its cap. */
 	deferred: number;
 	/**
@@ -89,9 +99,38 @@ function contentKey(content: string): string {
  * (still subject to the same duplicate and cap rules) but is not counted as a
  * step, because it is not one.
  */
-export function mergeTodos(existing: ExistingTodo[], steps: PlanStep[], max: number, trailing?: PlanStep): TodoMerge {
+export function mergeTodos(
+	existing: ExistingTodo[],
+	steps: PlanStep[],
+	max: number,
+	trailing?: PlanStep,
+	/** What an earlier approval of this plan seeded, when there was one. */
+	previous?: readonly string[],
+): TodoMerge {
 	const limit = Number.isInteger(max) && max > 0 ? max : DEFAULT_TODO_MAX;
-	const todos: ExistingTodo[] = existing.map((todo) =>
+	// A plan refined after approval is approved again over the list its first approval
+	// made. An item this plan seeded that is no longer one of its steps is a leftover, and
+	// only an item *this plan seeded* is a candidate: a user's own item is never touched.
+	const ours = new Set((previous ?? []).map(contentKey));
+	const current = new Set(steps.map((step) => contentKey(step.content)));
+	if (trailing) current.add(contentKey(trailing.content));
+	let replaced = 0;
+	let stale = 0;
+	const kept: ExistingTodo[] = [];
+	for (const todo of existing) {
+		const key = contentKey(todo.content);
+		if (ours.has(key) && !current.has(key)) {
+			// An untouched leftover is bookkeeping and goes; one someone acted on is
+			// evidence of work, and is named rather than deleted.
+			if (todo.status === "pending") {
+				replaced += 1;
+				continue;
+			}
+			stale += 1;
+		}
+		kept.push(todo);
+	}
+	const todos: ExistingTodo[] = kept.map((todo) =>
 		todo.status === "in_progress" && !todo.activeForm ? { ...todo, activeForm: todo.content } : todo,
 	);
 	const seen = new Set(todos.map((todo) => contentKey(todo.content)));
@@ -126,5 +165,14 @@ export function mergeTodos(existing: ExistingTodo[], steps: PlanStep[], max: num
 		}
 	}
 
-	return { todos, added, skipped, kept: existing.length, deferred, trailing: trailingOutcome };
+	return {
+		todos,
+		added,
+		skipped,
+		kept: existing.length - replaced,
+		replaced,
+		stale,
+		deferred,
+		trailing: trailingOutcome,
+	};
 }

package/extensions/plan/tools/exit.ts

@@ -12,7 +12,6 @@ import { basename } from "node:path";
 import type { ExtensionAPI, ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import { sanitizeLine } from "../../../lib/format.ts";
-import { messageOf } from "../../../lib/errors.ts";
 import { lastGoal } from "../../../lib/goal-state.ts";
 import { GOAL_TOOL } from "../../../lib/tool-names.ts";
 import { reuseText, toolDetails } from "../../../lib/tui/chrome.ts";
@@ -25,8 +24,6 @@ import { mergeSummary, overCap, preview, verificationNote } from "../format.ts";
 import { sanitizePlanText } from "../plan-text.ts";
 import { planTitle, type StoredPlan } from "../plans.ts";
 import { reviewPlan } from "../review.ts";
-import { decideSplit, rosterCard, SPLIT_OFF_NOTE } from "../split.ts";
-import { writeTeam } from "../../../lib/plans/team.ts";
 import { EXIT_TOOL, SET_PLAN_STEPS_TOOL, type PlanRuntime } from "../runtime.ts";
 import { goalSection, MAX_STEPS, planStepSummary } from "../steps.ts";
 import type { ExitPlanModeDetails } from "../types.ts";
@@ -34,27 +31,11 @@ import type { PlanWebReview } from "../web.ts";
 import { firstTextLine } from "./nested.ts";
 import { seedTodos } from "./todo-seed.ts";
 
-const PlanUnitParams = Type.Object({
-	name: Type.String({ description: "Lowercase slug; the owner session takes it as its label." }),
-	paths: Type.Array(Type.String(), { description: "Repository-relative path prefixes this unit owns." }),
-	test: Type.String({ description: "The command that proves the unit is done." }),
-	dependsOn: Type.Optional(Type.Array(Type.String(), { description: "Units that must land first." })),
-	lead: Type.Optional(Type.Boolean({ description: "True for the one unit this session keeps." })),
-});
-
 const ExitPlanModeParams = Type.Object({
 	plan_path: Type.String({
 		description:
 			"Path to the plan file written by write_plan: the absolute path it returned, or the `~/…` form it displayed. A bare name resolves inside the plans directory. The user reviews this file.",
 	}),
-	units: Type.Optional(
-		Type.Array(PlanUnitParams, {
-			description:
-				"The plan's slices, when it has two or more independent ones the user will run in separate sessions. " +
-				"Only used when the plan.split setting is on; validation refuses an overlapping, looping, or oversized " +
-				"split before the review opens. Omit it to approve as one flow.",
-		}),
-	),
 });
 
 type ExitPlanModeArgs = Static<typeof ExitPlanModeParams>;
@@ -73,13 +54,15 @@ interface GoalOutcome {
  * Approving the plan *is* the decision, so neither a `planning` goal nor a
  * session with none is asked again. A final goal (`active` or `achieved`) is the
  * user's own: approving ordinary work never rewrites it. Recording runs through
- * the goal tool, so validation and the widget stay goal's, and no model turn is
- * spent.
+ * the goal tool when it is registered — validation and the widget stay goal's,
+ * and no model turn is spent — and stays silent when that sibling extension is
+ * not installed, because there is nothing to report and nothing to act on.
  */
-async function finalizeGoal(ctx: ExtensionToolContext, plan: StoredPlan): Promise<GoalOutcome> {
+async function finalizeGoal(pi: ExtensionAPI, ctx: ExtensionToolContext, plan: StoredPlan): Promise<GoalOutcome> {
 	const objective = planObjective(plan);
 	const current = lastGoal(ctx.sessionManager.getBranch());
 	if (current !== null && current.status !== "planning") return { objective };
+	if (!pi.getAllTools().some((tool) => tool.name === GOAL_TOOL)) return { objective };
 	const outcome = await ctx.executeTool(GOAL_TOOL, { objective, status: "active" });
 	const action = current === null ? "recorded" : "promoted";
 	return outcome.isError ? { objective, action, error: firstTextLine(outcome) } : { objective, action };
@@ -145,26 +128,6 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 				);
 			}
 
-			// The split is decided before the review opens, so a refused or rejected split
-			// never spends the user's review — and the screen can show what it approves.
-			const units = args.units?.map((unit) => ({
-				name: unit.name,
-				paths: [...unit.paths],
-				test: unit.test,
-				dependsOn: [...(unit.dependsOn ?? [])],
-				...(unit.lead ? { lead: true } : {}),
-			}));
-			const split = decideSplit(ctx.cwd, await runtime.plans.rootFor(ctx.cwd), units);
-			if (split.kind === "refused") {
-				return failedResult(`Refused: ${split.reason}`, {
-					approved: false,
-					plan: file.content,
-					planPath: file.path,
-					relativePath: file.relativePath,
-				} satisfies ExitPlanModeDetails);
-			}
-			const pending = split.kind === "team" ? split : undefined;
-
 			if (!ctx.hasUI) {
 				return failedResult(
 					`No interactive UI is available to approve the plan. It is saved at ${file.relativePath}; present it and ask the user to approve it in their reply.`,
@@ -187,7 +150,6 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 				baselines: runtime,
 				plan: file,
 				signal,
-				...(pending === undefined ? {} : { split: { ...pending.team, verdict: pending.verdict } }),
 			});
 
 			if (decision.action === "refine") {
@@ -250,33 +212,18 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 				};
 			}
 
-			// The team becomes real here, never before: the section is what a joining
-			// session reads, so it appears only after the user approved the split. The
-			// write happens while plan mode is still on, so a failure leaves the session
-			// able to retry instead of approved-but-empty.
-			let approved = decision.plan;
-			if (pending !== undefined) {
-				try {
-					approved = await runtime.plans.write(ctx.cwd, {
-						title: planTitle(basename(decision.plan.path)),
-						content: writeTeam(decision.plan.content, { lead: pending.team.lead, units: pending.team.units }),
-						planPath: decision.plan.path,
-					});
-				} catch (writeError) {
-					return failedResult(
-						`The plan was approved but its team could not be written: ${messageOf(writeError)}. Plan mode is still on and no steps were seeded; fix the plan file and call exit_plan_mode again.`,
-						{
-							approved: false,
-							plan: decision.plan.content,
-							planPath: decision.plan.path,
-							relativePath: decision.plan.relativePath,
-						} satisfies ExitPlanModeDetails,
-					);
-				}
-			}
 			runtime.disable(ctx);
-			const { steps, merged, error } = await seedTodos(pi, ctx, approved.content);
-			const goal = await finalizeGoal(ctx, approved);
+			// A plan refined and approved again seeds over the list its first approval made:
+			// the steps that approval appended are the ones this one may replace.
+			const previous = runtime.seeded(decision.plan.path);
+			const { steps, merged, error } = await seedTodos(pi, ctx, decision.plan.content, previous);
+			if (error === undefined && steps.length > 0) {
+				runtime.markSeeded(
+					decision.plan.path,
+					steps.map((step) => step.content),
+				);
+			}
+			const goal = await finalizeGoal(pi, ctx, decision.plan);
 			const listing =
 				steps.length > 0
 					? `\n\n${steps
@@ -303,41 +250,19 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 			const browserNote = decision.comments.length
 				? `\n\nThe user approved from the browser review with these comments:\n${feedbackSummary(decision.comments)}`
 				: "";
-			const splitNote =
-				pending === undefined
-					? split.kind === "off"
-						? `\n\n${SPLIT_OFF_NOTE}`
-						: ""
-					: `\n\n${rosterCard(pending.team, approved.path, pi.getSessionName())}\n\nWork only your own unit (${pending.team.lead}); the other units belong to the sessions the user starts.`;
 			return {
 				content: [
 					{
 						type: "text",
-						text: `Plan approved. Plan mode is off and write access is restored. The plan file ${approved.relativePath} is the source of truth; follow its steps.${browserNote}${splitNote}${tail}${verification}${goalNote}${listing}`,
+						text: `Plan approved. Plan mode is off and write access is restored. The plan file ${decision.plan.relativePath} is the source of truth; follow its steps.${browserNote}${tail}${verification}${goalNote}${listing}`,
 					},
 				],
 				details: {
 					approved: true,
-					plan: approved.content,
-					planPath: approved.path,
-					relativePath: approved.relativePath,
+					plan: decision.plan.content,
+					planPath: decision.plan.path,
+					relativePath: decision.plan.relativePath,
 					annotations: decision.comments.length > 0 ? decision.comments : undefined,
-					...(pending === undefined
-						? split.kind === "off"
-							? { splitOff: true }
-							: {}
-						: {
-								team: {
-									lead: pending.team.lead,
-									verdict: pending.verdict,
-									units: pending.team.units.map((unit) => ({
-										name: unit.name,
-										paths: unit.paths,
-										test: unit.test,
-										dependsOn: unit.dependsOn,
-									})),
-								},
-							}),
 				} satisfies ExitPlanModeDetails,
 			};
 		},

package/extensions/plan/tools/todo-seed.ts

@@ -36,14 +36,16 @@ export async function seedTodos(
 	pi: ExtensionAPI,
 	ctx: ExtensionToolContext,
 	plan: string,
+	/** What an earlier approval of the same plan appended, when it was approved before. */
+	previous?: readonly string[],
 ): Promise<{ steps: PlanStep[]; merged?: TodoMerge; error?: string }> {
 	const steps = extractPlanSteps(plan);
 	const verification = verificationItem(plan);
 	if (steps.length === 0 && !verification) return { steps };
-	const merged = mergeTodos(lastTodos(ctx.sessionManager.getBranch()), steps, todoMaxItems(pi), verification);
+	const merged = mergeTodos(lastTodos(ctx.sessionManager.getBranch()), steps, todoMaxItems(pi), verification, previous);
 	// Nothing new to write: every step (and the verification item) is already in
 	// the list, or the list is full, so a rewrite would only churn the widget.
-	if (merged.added === 0 && merged.trailing !== "added") return { steps, merged };
+	if (merged.added === 0 && merged.trailing !== "added" && merged.replaced === 0) return { steps, merged };
 	const outcome = await ctx.executeTool(TODO_TOOL, { todos: merged.todos });
 	if (!outcome.isError) return { steps, merged };
 	// The nested call fails both when the tool is unavailable and when it rejects

package/extensions/plan/tools/write.ts

@@ -93,8 +93,19 @@ export function registerWriteTool(pi: ExtensionAPI, runtime: PlanRuntime): void
 				// write; say so once, where the user is looking.
 				const moved = runtime.plans.takeNotice();
 				if (moved) ctx.ui.notify(moved, "info");
+				// A refinement says where the text it replaced went: a reviewer's comment that was
+				// carried to a block that moved can be checked against what she actually read.
+				const kept =
+					file.replaced === undefined ? "" : `, keeping the revision it replaced at ${file.replaced.relativePath}`;
+				// A plan that was approved before is now out of step with the todo list, and
+				// the list is only re-seeded by approving it again. Say so here, where the
+				// refinement is made, instead of letting the two disagree in silence.
+				const reseed =
+					runtime.seeded(file.path) === undefined
+						? ""
+						: " This plan was approved before: its todo items are the ones that approval seeded, and approving it again replaces the steps that changed (an item you started or finished is left alone and named).";
 				return textResult(
-					`Wrote the plan to ${file.relativePath}. Call exit_plan_mode with plan_path: ${file.path}${stepElisionNote(summary.elided)}`,
+					`Wrote the plan to ${file.relativePath}${kept}. Call exit_plan_mode with plan_path: ${file.path}${stepElisionNote(summary.elided)}${reseed}`,
 					{ path: file.path, relativePath: file.relativePath, bytes: file.bytes } satisfies WritePlanDetails,
 				);
 			} catch (error) {

package/extensions/plan/tui.ts

@@ -29,7 +29,6 @@ import {
 	type TuiMouseEventResult,
 } from "@earendil-works/pi-tui";
 import { sanitizeLine } from "../../lib/format.ts";
-import { renderTeam, type PlanUnit } from "../../lib/plans/team.ts";
 import {
 	editorTheme,
 	screenHint,
@@ -46,7 +45,6 @@ import { emptyState, checkbox } from "../../lib/tui/rows.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import { planTitle, type StoredPlan } from "./plans.ts";
 import { changedSections, planDisplayText, type SectionDigest } from "./plan-text.ts";
-import { extractPlanSections } from "./steps.ts";
 
 /** What the user chose from the read/review screen. */
 export type PlanViewAction = "approve" | "refine" | "keep" | "browser" | "cancel";
@@ -87,11 +85,6 @@ export interface PlanViewOptions {
 	tui?: TUI;
 	/** Markdown theme for the body; defaults to Pi's active theme. */
 	markdownTheme?: MarkdownTheme;
-	/**
-	 * The split approval would write. Rendered as a read-only section after the
-	 * plan, because the `## Team` section itself only exists after approval.
-	 */
-	split?: { lead: string; units: readonly PlanUnit[]; verdict: "pair" | "team" };
 }
 
 /** Rows the screen shows when the terminal height is unknown. */
@@ -207,11 +200,10 @@ export class PlanViewComponent implements Component {
 		const base = this.options.markdownTheme ?? getMarkdownTheme();
 		const theme = planMarkdownTheme(this.theme, base);
 		const current = planDisplayText(this.options.plan.content);
-		const changed = changedSections(this.options.baseline, current);
-		const chunks = extractPlanSections(current);
+		const marks = changedSections(this.options.baseline, current);
 		const lines: string[] = [];
 		const sections: SectionOffset[] = [];
-		chunks.forEach((chunk, index) => {
+		marks.forEach(({ section: chunk, changed }, index) => {
 			// Markdown pads every line to the full width for backgrounds; this screen
 			// draws no background, so the padding is dropped.
 			const rendered = new Markdown(chunk.text, padding, 0, theme)
@@ -220,38 +212,17 @@ export class PlanViewComponent implements Component {
 			sections.push({
 				title: chunk.title,
 				offset: lines.length,
-				...(changed[index] ? { changed: true } : {}),
+				...(changed ? { changed: true } : {}),
 			});
 			lines.push(...rendered);
 			// Sections render independently, so restore the blank line a heading-only
 			// chunk omits before the next section.
-			if (index < chunks.length - 1 && lines.length > 0 && lines[lines.length - 1] !== "") lines.push("");
+			if (index < marks.length - 1 && lines.length > 0 && lines[lines.length - 1] !== "") lines.push("");
 		});
-		const split = this.splitSection();
-		if (split !== undefined) {
-			if (lines.length > 0 && lines[lines.length - 1] !== "") lines.push("");
-			const rendered = new Markdown(split, padding, 0, theme)
-				.render(width)
-				.map((line) => truncateToWidth(line.trimEnd(), width));
-			sections.push({ title: "Split", offset: lines.length });
-			lines.push(...rendered);
-		}
-		this.cache = { width, lines, sections, changedCount: changed.filter(Boolean).length };
+		this.cache = { width, lines, sections, changedCount: marks.filter((mark) => mark.changed).length };
 		return this.cache;
 	}
 
-	/**
-	 * The split as a read-only section: the same table approval writes, so what the
-	 * user approves is what the plan file will carry.
-	 */
-	private splitSection(): string | undefined {
-		const split = this.options.split;
-		if (split === undefined) return undefined;
-		const owners = split.units.filter((unit) => !unit.lead).length;
-		const summary = `${split.verdict} · lead + ${owners} owner${owners === 1 ? "" : "s"} · written on approval`;
-		return ["## Split", "", summary, "", renderTeam({ lead: split.lead, units: [...split.units] })].join("\n");
-	}
-
 	/** The section whose heading is at or above the viewport top. */
 	private currentSection(sections: SectionOffset[]): SectionOffset | undefined {
 		let current: SectionOffset | undefined;

package/extensions/plan/types.ts

@@ -50,6 +50,21 @@ export interface ReviewBaselineEntry {
 	sections: SectionDigest[];
 }
 
+/**
+ * What one approval put into the todo list, so the next approval can replace it.
+ *
+ * A plan refined after it was approved is approved again, and the list still holds the
+ * items seeded the first time. Their texts are the only record of which items came from
+ * this plan, so a re-approval keeps them to recognise — and replace — its own leftovers
+ * without touching an item the user was already tracking.
+ */
+export interface SeededStepsEntry {
+	/** Resolved path of the approved plan file. */
+	path: string;
+	/** The step texts the approval appended, in order. */
+	steps: string[];
+}
+
 /** Structured result carried in `enter_plan_mode`'s `details`. */
 export interface EnterPlanModeDetails {
 	/** Whether the user agreed to enter plan mode. */
@@ -104,14 +119,6 @@ export interface ExitPlanModeDetails {
 	cancelled?: boolean;
 	/** True when no interactive UI was available to ask for approval. */
 	unavailable?: boolean;
-	/** The team approval wrote into the plan, when the plan was split. */
-	team?: {
-		lead: string;
-		units: Array<{ name: string; paths: string[]; test: string; dependsOn: string[] }>;
-		verdict: "pair" | "team";
-	};
-	/** True when the model proposed a split while `plan.split` was off. */
-	splitOff?: boolean;
 }
 
 /** Structured result carried in `cancel_plan_mode`'s `details`. */

package/extensions/plan/web-blocks.ts

@@ -0,0 +1,89 @@
+/**
+ * The review page's block navigation: which block is active, and how a key walks them.
+ *
+ * The fourth capability out of the review client's template literal. Each function takes
+ * the document it reads and returns the index it computed, so the client keeps the one
+ * variable (`activeIndex`) and these own the rules: clamp to the blocks that exist, start
+ * at the first or last when nothing is active, and land beside the reader rather than
+ * jumping to the middle of the page.
+ *
+ * `el` comes from the runtime, declared here because this source is spliced into the same
+ * bundle; the declaration emits nothing.
+ */
+
+import type { ClientNode } from "../../lib/web/client-runtime.ts";
+
+/** The island's view of one block, as far as navigation needs it. */
+export interface IslandBlock {
+	start: number;
+	kind?: string;
+}
+
+/**
+ * The rendered blocks.
+ *
+ * A rebuild replaces them, so this is read fresh rather than remembered: the array a
+ * caller holds goes stale the moment `renderPlan` throws the DOM away.
+ */
+export function blockElements(planEl: ClientNode | null): ClientNode[] {
+	if (!planEl) return [];
+	const nodes = planEl.querySelectorAll(".bf-block");
+	const blocks: ClientNode[] = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const block = nodes[i];
+		if (block) blocks.push(block);
+	}
+	return blocks;
+}
+
+/**
+ * Make one block active and bring it into view, or say nothing when there are no blocks.
+ *
+ * `null` means "nothing changed": a page with no blocks has no active block, and the
+ * caller keeps the index it had rather than being reset to zero.
+ */
+export function setActive(planEl: ClientNode | null, index: number): number | null {
+	const blocks = blockElements(planEl);
+	if (blocks.length === 0) return null;
+	const next = Math.max(0, Math.min(blocks.length - 1, index));
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		if (block) block.classList.toggle("bf-block--active", i === next);
+	}
+	const current = blocks[next];
+	if (current && current.scrollIntoView) current.scrollIntoView({ block: "nearest" });
+	return next;
+}
+
+/**
+ * The index one step from `activeIndex`, or `null` when there is nothing to walk.
+ *
+ * With nothing active yet, `j` starts at the top and `k` at the bottom, which is what a
+ * reader pressing either key on a fresh page expects.
+ */
+export function moveActive(planEl: ClientNode | null, activeIndex: number, delta: number): number | null {
+	const blocks = blockElements(planEl);
+	if (blocks.length === 0) return null;
+	const next = activeIndex < 0 ? (delta < 0 ? blocks.length - 1 : 0) : activeIndex + delta;
+	return setActive(planEl, next);
+}
+
+/**
+ * The rendered block and its island block for a source line, when both exist.
+ *
+ * Both halves are required: a rendered block with no island entry has nothing to comment
+ * on, and an island entry with no rendered block is a comment the page cannot place.
+ */
+export function blockAtLine(
+	planEl: ClientNode | null,
+	blocks: readonly IslandBlock[],
+	line: number,
+): { wrap: ClientNode; block: IslandBlock } | null {
+	const wrap = planEl ? planEl.querySelector('.bf-block[data-line="' + line + '"]') : null;
+	let block: IslandBlock | undefined;
+	for (const candidate of blocks) if (candidate.start === line) block = candidate;
+	return wrap && block ? { wrap, block } : null;
+}
+
+/** The block rules as source, for the client bundle. */
+export const WEB_BLOCKS_JS = [blockElements, setActive, moveActive, blockAtLine].map(String).join("\n\n");