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

package/extensions/plan/policy.ts

@@ -14,26 +14,30 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { createReadOnlyPolicy, type ReadOnlyPolicy } from "../../lib/policy.ts";
-import { ASK_USER_QUESTION_TOOL, GOAL_TOOL, SUBAGENT_TOOL, TODO_TOOL } from "../../lib/tool-names.ts";
+import { createReadOnlyPolicy, WORKSPACE_READERS, type ReadOnlyPolicy } from "../../lib/policy.ts";
+import {
+	ASK_USER_QUESTION_TOOL,
+	GOAL_TOOL,
+	SUBAGENT_TOOL,
+	TODO_TOOL,
+	WEB_FETCH_TOOL,
+	WEB_SEARCH_TOOL,
+} from "../../lib/tool-names.ts";
 import { ENTER_TOOL } from "./runtime.ts";
 
 /**
- * Tools that stay available while planning: structured readers, the trackers,
- * the git-only `bash`, and the known web/question readers. They are also the
- * tools the path backstop does not second-guess.
+ * Tools that stay available while planning: structured readers (documents
+ * included), the trackers, the git-only `bash`, and the known web/question
+ * readers. They are also the tools the path backstop does not second-guess.
  */
 export const PLAN_SAFE_TOOLS = [
-	"read",
-	"grep",
-	"find",
-	"ls",
+	...WORKSPACE_READERS,
 	TODO_TOOL,
 	GOAL_TOOL,
 	"bash",
 	ASK_USER_QUESTION_TOOL,
-	"web_search",
-	"web_fetch",
+	WEB_SEARCH_TOOL,
+	WEB_FETCH_TOOL,
 ];
 
 /**
@@ -43,7 +47,11 @@ export const PLAN_SAFE_TOOLS = [
  * deliberately absent — it is default-denied like any other shell.
  */
 export const PLAN_ALLOWED_TOOLS = [...PLAN_SAFE_TOOLS, SUBAGENT_TOOL];
-/** Tools always blocked while planning, even when annotated read-only. */
+/**
+ * Tools always blocked while planning, even when annotated read-only.
+ * `enter_plan_mode` is denied so it stays hidden while planning; the guard exempts
+ * plan's own registration so a call already in flight can still answer "already".
+ */
 const ALWAYS_BLOCKED_TOOLS = ["write", "edit", ENTER_TOOL];
 
 /** Shown when a tool call is refused while planning. */

package/extensions/plan/review.ts

@@ -17,7 +17,6 @@ import type { ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import { askHuman, isRemoteTurn, remoteLanguage } from "../../lib/interaction.ts";
 import { FULL_SCREEN_OVERLAY } from "../../lib/tui/chrome.ts";
 import { feedbackSummary, type PlanAnnotation } from "./feedback.ts";
-import type { PlanUnit } from "../../lib/plans/team.ts";
 import type { PlanStore, StoredPlan } from "./plans.ts";
 import type { SectionDigest } from "./plan-text.ts";
 import { planReviewPrompt, parsePlanReviewReply } from "./review-prompt.ts";
@@ -64,15 +63,6 @@ export interface ReviewPlanOptions {
 	plan: StoredPlan;
 	/** Aborting the turn closes a browser review and returns the plan unapproved. */
 	signal?: AbortSignal;
-	/** The split approval would write, so the screen shows what is being approved. */
-	split?: ReviewSplit;
-}
-
-/** A validated split, as the review screen displays it. */
-export interface ReviewSplit {
-	lead: string;
-	units: readonly PlanUnit[];
-	verdict: "pair" | "team";
 }
 
 /** Prompt shown by the dialog-based refine editor in non-TUI modes. */
@@ -94,7 +84,6 @@ async function askPlanReview(
 	ctx: ExtensionToolContext,
 	plan: StoredPlan,
 	baseline: SectionDigest[] | undefined,
-	split: ReviewSplit | undefined,
 ): Promise<PlanReviewChoice> {
 	const language = remoteLanguage(ctx) ?? "en";
 	const remote = isRemoteTurn(ctx);
@@ -105,7 +94,6 @@ async function askPlanReview(
 					new PlanViewComponent({
 						plan,
 						baseline,
-						...(split === undefined ? {} : { split }),
 						theme,
 						onClose: (action, refinement) => done({ action, refinement }),
 						requestRender: () => tui.requestRender(),
@@ -143,8 +131,6 @@ export interface BrowserReviewOptions {
 	 * they are waiting: the page updates itself, the terminal has to be told.
 	 */
 	onReviewerComment?: (author: string, count: number) => void;
-	/** A line the page shows the owner, such as why approval belongs in the terminal. */
-	note?: string;
 }
 
 /**
@@ -163,7 +149,6 @@ export async function runBrowserReview(
 			canApprove: options.canApprove,
 			baseline: options.baseline,
 			signal: options.signal,
-			...(options.note === undefined ? {} : { note: options.note }),
 			...(options.onReviewerComment === undefined ? {} : { onReviewerComment: options.onReviewerComment }),
 		})
 		.catch(() => undefined);
@@ -182,7 +167,7 @@ export async function runBrowserReview(
  * cancelled returns to the screen it was opened from.
  */
 export async function reviewPlan(options: ReviewPlanOptions): Promise<ReviewDecision> {
-	const { ctx, web, plans, baselines, signal, split } = options;
+	const { ctx, web, plans, baselines, signal } = options;
 	let plan = options.plan;
 	for (;;) {
 		// An aborted turn has nobody left to answer the screen.
@@ -190,7 +175,7 @@ export async function reviewPlan(options: ReviewPlanOptions): Promise<ReviewDeci
 		// 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 baseline = baselines.reviewed(plan.path);
-		const choice = await askPlanReview(ctx, plan, baseline, split);
+		const choice = await askPlanReview(ctx, plan, baseline);
 		baselines.markReviewed(plan.path, plan.content);
 
 		if (choice.action === "approve") return { action: "approve", plan, comments: [] };
@@ -206,17 +191,8 @@ export async function reviewPlan(options: ReviewPlanOptions): Promise<ReviewDeci
 		// An unrecognized action keeps planning rather than opening a server.
 		if (choice.action !== "browser") return { action: "keep", plan };
 
-		// A split section exists only after approval, and the page anchors comments to
-		// source lines, so a page cannot show — or approve — a plan it cannot carry.
-		// The terminal review is where the split is approved.
-		const splitNote =
-			split === undefined
-				? undefined
-				: "This plan has a split, which the page cannot show; approve it in the terminal review.";
-		if (splitNote !== undefined) ctx.ui.notify(splitNote, "info");
 		const result = await runBrowserReview(web, ctx.cwd, plan, {
-			canApprove: split === undefined,
-			...(splitNote === undefined ? {} : { note: splitNote }),
+			canApprove: true,
 			baseline,
 			signal,
 			onOpened: (session) => ctx.ui.notify(`Plan review: opened ${session.url}`, "info"),

package/extensions/plan/runtime.ts

@@ -11,8 +11,8 @@
  * markers survive a resume too.
  *
  * `write_plan` is the one sanctioned write while planning. The read-only guard
- * in `index.ts` permits a control tool only when the registered tool is this
- * extension's own (matched by source path), so a same-named tool from another
+ * in `index.ts` permits plan's own tools only when the registered tool is this
+ * extension's (matched by source path), so a same-named tool from another
  * extension cannot borrow the exemption.
  */
 
@@ -48,9 +48,17 @@ export const BASELINE_TYPE = "plan-baseline";
 /** Longest plan-file basename shown in the footer chip. */
 const STATUS_NAME_LENGTH = 28;
 
-/** Tools plan mode activates itself; the guard permits only this extension's own. */
+/** Tools plan mode activates itself. */
 const CONTROL_TOOLS = [EXIT_TOOL, CANCEL_TOOL, WRITE_PLAN_TOOL];
 
+/**
+ * Tools the read-only guard exempts when this extension registered them.
+ * `enter_plan_mode` is here only so a call already in flight when plan mode came on
+ * is answered by the tool ("already in plan mode"); the policy still denies it, so
+ * it stays hidden while planning.
+ */
+const OWNED_TOOLS = [...CONTROL_TOOLS, ENTER_TOOL];
+
 export interface PlanRuntime {
 	/** Whether plan mode is currently on. */
 	isEnabled(): boolean;
@@ -61,8 +69,8 @@ export interface PlanRuntime {
 	restore(ctx: ExtensionContext): void;
 	/** Plan-file storage for `write_plan` and `exit_plan_mode`. */
 	plans: PlanStore;
-	/** Whether `toolName` is a plan-owned control tool (not a same-named impostor). */
-	isControlTool(toolName: string): boolean;
+	/** Whether `toolName` is one of plan's own tools (not a same-named impostor) the read-only guard exempts. */
+	isOwnTool(toolName: string): boolean;
 	/** Path of the most recently written plan, for the footer chip. */
 	lastPlanPath(): string | undefined;
 	/** Remember a written plan and repaint the footer. */
@@ -159,11 +167,15 @@ export function createPlanRuntime(
 
 	const plans = createPlanStore(pi);
 
-	const isControlTool = (toolName: string): boolean => {
-		if (!CONTROL_TOOLS.includes(toolName)) return false;
+	/**
+	 * Whether `toolName` is plan's own registration, matched by the entry path the
+	 * host recorded. Older hosts may not record a source; only a recorded mismatch
+	 * is rejected.
+	 */
+	const isOwnTool = (toolName: string): boolean => {
+		if (!OWNED_TOOLS.includes(toolName)) return false;
 		const info = pi.getAllTools().find((tool) => tool.name === toolName);
 		const source = info?.sourceInfo?.path;
-		// Older hosts may not record a source; only reject a recorded mismatch.
 		return source === undefined || options.entryPath === undefined || samePath(source, options.entryPath);
 	};
 
@@ -241,7 +253,7 @@ export function createPlanRuntime(
 			if (ctx) setStatus(ctx);
 		},
 		plans,
-		isControlTool,
+		isOwnTool,
 		lastPlanPath: () => lastPlanPath,
 		setLastPlan: (ctx, path) => {
 			lastPlanPath = path;

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/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,9 @@ 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);
+			const { steps, merged, error } = await seedTodos(pi, ctx, decision.plan.content);
+			const goal = await finalizeGoal(pi, ctx, decision.plan);
 			const listing =
 				steps.length > 0
 					? `\n\n${steps
@@ -303,41 +241,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/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

@@ -104,14 +104,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-client.ts

@@ -1,7 +1,7 @@
 /**
  * The browser review client, served as `/client.js`.
  *
- * Kept as one self-contained script (like `file-browse/client.ts`) with no
+ * Kept as one self-contained script (like `file-browse/view/client.ts`) with no
  * build step. Its document half — the inline and block Markdown rendering — is
  * `web-markdown.ts`, a fragment of the same IIFE interpolated below. It renders
  * the plan from the JSON data island using DOM text nodes only — plan and