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

package/extensions/plan/review.ts

@@ -1,9 +1,9 @@
 /**
  * The plan review gate: ask the human about a plan file and return one decision.
  *
- * A review has three presentations — the scrollable TUI screen, a select plus
- * editor for dialog-only modes, and a remote turn's plan file plus digest — and
- * one optional browser server. This module owns the loop that switches between
+ * A review has three presentations — the scrollable TUI screen, a dialog-only
+ * editor, and a remote turn's compact editor prompt — and one optional browser
+ * server. This module owns the loop that switches between
  * them, so `exit_plan_mode` and `/plan review` share one lifecycle and only map
  * the returned {@link ReviewDecision} to their own result.
  *
@@ -12,14 +12,15 @@
  * signal reaches the browser server so an aborted turn closes it.
  */
 
-import type { ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import { basename } from "node:path";
-import { askHuman } from "../../lib/interaction.ts";
+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 { extractPlanSteps } from "./steps.ts";
+import { planReviewPrompt, parsePlanReviewReply } from "./review-prompt.ts";
 import { PlanViewComponent, type PlanViewAction } from "./tui.ts";
 import type { PlanReviewResult, PlanReviewSession, PlanWebReview } from "./web.ts";
 
@@ -29,9 +30,6 @@ interface PlanReviewChoice {
 	refinement?: string;
 }
 
-/** A dialog-only choice: post the full plan text, then ask again. Never returned. */
-type ReviewChoice = PlanReviewChoice | { action: "send" };
-
 /** What a review decided, and the plan state it decided on. */
 export type ReviewDecision =
 	| { action: "approve"; plan: StoredPlan; comments: PlanAnnotation[] }
@@ -66,6 +64,15 @@ 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. */
@@ -78,98 +85,47 @@ const REFINE_PROMPT = "Refine the plan — what should change? (Enter to save, E
  */
 export const PLAN_REVIEW_TIMEOUT_MS = 600_000;
 
-/** How much of one step the remote digest shows. */
-const DIGEST_STEP_CHARS = 90;
-
-/**
- * A one-message digest of the plan for a remote review.
- *
- * The file is the primary artifact, but a phone client may never render or open
- * it, and the peer still has to choose approve / refine. The digest carries the
- * title, the step count, and the first few steps; the full text follows as a
- * file or as the fallback message.
- */
-function planReviewDigest(content: string): string {
-	const title = /^#\s+(.+)$/m.exec(content)?.[1]?.trim();
-	const steps = extractPlanSteps(content);
-	const count = steps.length;
-	const head = `Plan${title ? `: ${title}` : ""}${count > 0 ? ` (${count} step${count === 1 ? "" : "s"})` : ""}`;
-	const preview = steps.slice(0, 3).map((step, index) => {
-		const text = step.content.replace(/\s+/g, " ").trim();
-		const shown = text.length > DIGEST_STEP_CHARS ? `${text.slice(0, DIGEST_STEP_CHARS - 1)}…` : text;
-		return `${index + 1}. ${shown}`;
-	});
-	const more = count > preview.length ? `… (${count - preview.length} more)` : "";
-	return [
-		head,
-		...preview,
-		more,
-		"Plan mode is on — write access is off. Choose “Exit plan mode” to leave without approving.",
-		"The full plan is attached above, or sent as text if the file failed.",
-	]
-		.filter((line) => line !== "")
-		.join("\n");
-}
-
 /**
- * Ask the user to review the plan file. The TUI opens the scrollable review
- * screen (with an inline refine editor); dialog-capable modes (RPC) fall back to
- * a select plus the refine editor; a remote turn gets the plan file and a digest
- * first. Asking for the full plan re-enters with the text only, then shows the
- * choices again.
+ * Ask the user to review the plan file. The TUI opens the scrollable screen;
+ * dialog-capable modes (RPC/WeChat) get one editor prompt. A reply that is not an
+ * action is a refinement.
  */
 async function askPlanReview(
 	ctx: ExtensionToolContext,
 	plan: StoredPlan,
 	baseline: SectionDigest[] | undefined,
+	split: ReviewSplit | undefined,
 ): Promise<PlanReviewChoice> {
-	let sentFullText = false;
-	for (;;) {
-		const outcome = await askHuman<ReviewChoice>(ctx, {
-			custom: async () => {
-				const choice = await ctx.ui.custom<PlanReviewChoice | undefined>(
-					(tui, theme, _keybindings, done) =>
-						new PlanViewComponent({
-							plan,
-							baseline,
-							theme,
-							onClose: (action, refinement) => done({ action, refinement }),
-							requestRender: () => tui.requestRender(),
-							viewportRows: () => tui.terminal?.rows,
-							tui,
-						}),
-					FULL_SCREEN_OVERLAY,
-				);
-				return choice ?? { action: "keep" };
-			},
-			dialogs: async () => {
-				const choice = await ctx.ui.select("Plan mode — what next?", [
-					"Approve and execute",
-					"Send the full plan",
-					"Refine the plan",
-					"Keep planning (stay in plan mode)",
-					"Exit plan mode (discard)",
-				]);
-				if (choice === "Approve and execute") return { action: "approve" };
-				if (choice === "Send the full plan") return { action: "send" };
-				if (choice === "Refine the plan") return { action: "refine" };
-				if (choice === "Keep planning (stay in plan mode)") return { action: "keep" };
-				// Dismissing the plan gate means leaving plan mode, not silently staying
-				// in it. The explicit Keep choice above is the only way to stay.
-				return { action: "cancel" };
-			},
-			// A remote turn gets the plan file up front, falling back to the full text;
-			// a local TUI turn ignores both and renders the component. The digest goes
-			// out either way so the choices stay answerable when a phone client does not
-			// render the file bubble.
-			file: sentFullText ? undefined : { path: plan.path, name: basename(plan.relativePath) },
-			body: plan.content,
-			note: sentFullText ? undefined : planReviewDigest(plan.content),
-			timeoutMs: PLAN_REVIEW_TIMEOUT_MS,
-		});
-		if (outcome.action !== "send") return outcome;
-		sentFullText = true;
-	}
+	const language = remoteLanguage(ctx) ?? "en";
+	const remote = isRemoteTurn(ctx);
+	return askHuman<PlanReviewChoice>(ctx, {
+		custom: async () => {
+			const choice = await ctx.ui.custom<PlanReviewChoice | undefined>(
+				(tui, theme, _keybindings, done) =>
+					new PlanViewComponent({
+						plan,
+						baseline,
+						...(split === undefined ? {} : { split }),
+						theme,
+						onClose: (action, refinement) => done({ action, refinement }),
+						requestRender: () => tui.requestRender(),
+						viewportRows: () => tui.terminal?.rows,
+						tui,
+					}),
+				FULL_SCREEN_OVERLAY,
+			);
+			return choice ?? { action: "keep" };
+		},
+		dialogs: async () => {
+			const answer = await ctx.ui.editor(planReviewPrompt(plan.content, language, remote), "");
+			return parsePlanReviewReply(answer ?? "");
+		},
+		// The full plan is the artifact under review, so it goes out before the
+		// choices; if the upload fails, the same text is the fallback.
+		file: { path: plan.path, name: basename(plan.relativePath) },
+		body: plan.content,
+		timeoutMs: PLAN_REVIEW_TIMEOUT_MS,
+	});
 }
 
 /** How a browser review may decide, and what to report when it opens. */
@@ -182,6 +138,13 @@ export interface BrowserReviewOptions {
 	signal?: AbortSignal;
 	/** Called once the server is listening and the browser was opened. */
 	onOpened?: (session: PlanReviewSession) => void;
+	/**
+	 * Called when a shared reviewer's post lands, so the owner learns about it where
+	 * 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;
 }
 
 /**
@@ -196,7 +159,13 @@ export async function runBrowserReview(
 ): Promise<PlanReviewResult | undefined> {
 	if (options.signal?.aborted) return { status: "cancelled" };
 	const session = await web
-		.start(cwd, plan, { canApprove: options.canApprove, baseline: options.baseline, signal: options.signal })
+		.start(cwd, plan, {
+			canApprove: options.canApprove,
+			baseline: options.baseline,
+			signal: options.signal,
+			...(options.note === undefined ? {} : { note: options.note }),
+			...(options.onReviewerComment === undefined ? {} : { onReviewerComment: options.onReviewerComment }),
+		})
 		.catch(() => undefined);
 	if (!session) return undefined;
 	options.onOpened?.(session);
@@ -213,7 +182,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 } = options;
+	const { ctx, web, plans, baselines, signal, split } = options;
 	let plan = options.plan;
 	for (;;) {
 		// An aborted turn has nobody left to answer the screen.
@@ -221,7 +190,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);
+		const choice = await askPlanReview(ctx, plan, baseline, split);
 		baselines.markReviewed(plan.path, plan.content);
 
 		if (choice.action === "approve") return { action: "approve", plan, comments: [] };
@@ -237,11 +206,22 @@ 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: true,
+			canApprove: split === undefined,
+			...(splitNote === undefined ? {} : { note: splitNote }),
 			baseline,
 			signal,
 			onOpened: (session) => ctx.ui.notify(`Plan review: opened ${session.url}`, "info"),
+			onReviewerComment: (author, count) =>
+				ctx.ui.notify(`Plan review: @${author} posted ${count === 1 ? "a comment" : `${count} comments`}.`, "info"),
 		});
 		if (!result) {
 			ctx.ui.notify("Plan review: could not start the browser review server.", "error");

package/extensions/plan/runtime.ts

@@ -4,7 +4,7 @@
  * Enabling plan mode removes every tool the policy does not consider read-only
  * from the active set and activates the plan-mode control tools: `exit_plan_mode`
  * (present the plan for approval) and `write_plan` (save the plan artifact under
- * `.pi/plans`). Disabling restores exactly what it hid. The enabled flag is
+ * the plans directory). Disabling restores exactly what it hid. The enabled flag is
  * persisted as a custom session entry so `/resume` and `/tree` follow the
  * branch, and it is also mirrored into the footer status. The review baseline
  * travels the same way, as one digest per heading section, so the changed-section

package/extensions/plan/split.ts

@@ -0,0 +1,87 @@
+/**
+ * The split at approval: the switch that enables it, the roster card, and the
+ * `## Team` section it writes.
+ *
+ * Plan mode keeps one job — the plan document and its approval gate — and this
+ * module is the part of that gate that concerns a team: whether the feature is on,
+ * what the user is told to run in the sessions this package cannot start, and the
+ * write that makes the team real. Everything mechanical about the split itself
+ * (which tables are legal, which paths collide) is `lib/plans/split.ts`, because
+ * the bus reads the same section.
+ */
+
+import { sanitizeLine, shortenPath } from "../../lib/format.ts";
+import { splitEnabled } from "../../lib/plans/setting.ts";
+import { checkSplit, mergeOrder } from "../../lib/plans/split.ts";
+import type { PlanTeam, PlanUnit } from "../../lib/plans/team.ts";
+
+export { SPLIT_OFF_NOTE, SPLIT_SETTING_ID, SPLIT_SETTING_LABEL, splitEnabled } from "../../lib/plans/setting.ts";
+
+/** What approval decides about the units a model proposed. */
+export type SplitDecision =
+	| { kind: "none" }
+	| { kind: "off" }
+	| { kind: "refused"; reason: string }
+	| { kind: "serial" }
+	| { kind: "team"; team: PlanTeam; verdict: "pair" | "team" };
+
+/**
+ * Decide what to do with the `units` an approval carried.
+ *
+ * The switch is checked first: with it off the units are ignored entirely rather
+ * than validated, so a user who never enabled the feature cannot be blocked by a
+ * rule about it.
+ */
+export function decideSplit(
+	cwd: string,
+	root: string | undefined,
+	units: readonly PlanUnit[] | undefined,
+): SplitDecision {
+	if (units === undefined || units.length === 0) return { kind: "none" };
+	if (!splitEnabled(cwd, root)) return { kind: "off" };
+	const check = checkSplit(units);
+	if (!check.ok) return { kind: "refused", reason: check.reason };
+	if (check.verdict === "serial") return { kind: "serial" };
+	return { kind: "team", team: { lead: check.lead, units: check.units }, verdict: check.verdict };
+}
+
+/**
+ * The roster card: what the user runs, in which session, and in what order.
+ *
+ * A lead cannot start, name, or prompt a peer session, so the card is the whole of
+ * what step 3 can do — and its first line says so, because the rest of the flow
+ * depends on the user believing it.
+ */
+export function rosterCard(team: PlanTeam, planPath: string, sessionLabel?: string): string {
+	const lead = team.units.find((unit) => unit.lead)?.name ?? team.lead;
+	const owners = team.units.filter((unit) => !unit.lead);
+	const rows = owners.map((unit) => {
+		const join = `session({action:"join", team:"${teamName(planPath)}", unit:"${unit.name}"})`;
+		return `  ${unit.name}: enter_worktree ${unit.name} · /sessions name ${unit.name} · /sessions watch wake\n    ${join}`;
+	});
+	const order = mergeOrderLine(team);
+	// The lead's own label is the one line of the card it cannot get itself until
+	// after this card is printed, so the card either names it or says how to set it.
+	const name = sessionLabel?.trim();
+	const label = name
+		? `  your label: ${sanitizeLine(name)} — owners send their report there`
+		: `  your label: none — name this session: session({action:"name", label:"${lead}"})`;
+	return [
+		`Split: ${team.units.length} units · ${shortenPath(planPath)}`,
+		"  You start and switch every session; nothing here can.",
+		...rows,
+		`  ${order} · your unit: ${lead}`,
+		label,
+	].join("\n");
+}
+
+/** The team's name is the plan file's stem, so two plans never share one. */
+export function teamName(planPath: string): string {
+	const name = planPath.split(/[\\/]/).pop() ?? planPath;
+	return name.replace(/\.md$/i, "");
+}
+
+/** Merge order in one line, from the dependency graph the validation accepted. */
+export function mergeOrderLine(team: PlanTeam): string {
+	return `merge order: ${mergeOrder(team.units).join(" → ")}`;
+}

package/extensions/plan/steps.ts

@@ -10,13 +10,35 @@
  * the digest is computed over.
  *
  * Only top-level list items become steps: nested sub-bullets are notes, and the
- * shallowest list level is treated as the plan. When the plan has a `Steps`
- * section (the canonical outline's heading), only that section's list items are
- * steps, so prose bullets elsewhere never seed the todo list or consume the
- * step cap. List items inside fenced code blocks are ignored. A `- [ ]` / `- [x]`
+ * shallowest list level is treated as the plan. An indented, marker-less line
+ * continues the item above it, so a wrapped step keeps its full text. When the
+ * plan has a `Steps` section (the canonical outline's heading), only that
+ * section's list items are steps, so prose bullets elsewhere never seed the todo
+ * list or consume the step cap. List items inside fenced code blocks are ignored. A `- [ ]` / `- [x]`
  * 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";
+
 /** Most steps seeded from one plan. */
 export const MAX_STEPS = 50;
 /** Longest seeded step text; longer lines are elided. */
@@ -82,26 +104,17 @@ export interface PlanStep {
 	status: "pending" | "completed";
 }
 
-/** A heading-delimited chunk of the plan, for the review screen's navigation. */
-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 top-level list item located in the source. */
 interface PlanListItem {
-	/** Zero-based source line index. */
+	/** Zero-based source line index of the item's first line. */
 	line: number;
 	indent: number;
 	/** The list marker with its trailing whitespace, e.g. `1. ` or `- `. */
 	lead: string;
-	/** Item text after the marker, right-trimmed (an optional checkbox included). */
+	/**
+	 * Item text after the marker on its first line; indented continuation lines
+	 * are folded into {@link step}, so a checkbox edit rewrites only this line.
+	 */
 	raw: string;
 	step: PlanStep;
 }
@@ -109,39 +122,10 @@ interface PlanListItem {
 /** A top-level numbered or bulleted list item, capturing its parts. */
 const LIST_ITEM = /^([ \t]*)((?:\d+[.)]|[-*+])\s+)(.*\S)\s*$/;
 const CHECKBOX = /^\[([ xX])\]\s*(.*)$/;
-/**
- * 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 `blocks.ts`, 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
- * `blocks.ts`: 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,})/;
 const DONE_MARKER = /\[DONE:\d+\]/gi;
 
-/**
- * A heading or step label as the review surfaces compare it: inline emphasis and
- * code removed, whitespace collapsed. Exported so `blocks.ts` labels an outline
- * entry the same way `extractPlanSections` 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();
-}
-
-/** Strip inline markdown emphasis and code, then collapse to one clean line. */
-function plainText(text: string): string {
+/** A label with its inline markers and any done marker removed. */
+function cleanLabel(text: string): string {
 	return normalizeHeadingText(text.replace(DONE_MARKER, ""));
 }
 
@@ -157,7 +141,12 @@ function parseStep(raw: string): PlanStep {
 	}
 	if (/\[DONE:\d+\]/i.test(text)) done = true;
 
-	return { content: plainText(text), status: done ? "completed" : "pending" };
+	return { content: cleanLabel(text), status: done ? "completed" : "pending" };
+}
+
+/** Leading whitespace width of a line, for continuation indent checks. */
+function indentOf(line: string): number {
+	return line.length - line.trimStart().length;
 }
 
 /** Every top-level list item, in order, before de-duplication and capping. */
@@ -165,22 +154,57 @@ function scanListItems(plan: string): PlanListItem[] {
 	const items: PlanListItem[] = [];
 	// Fences hide example lists (`- name: foo` in a YAML block) from extraction.
 	let fence: string | undefined;
+	// The item still collecting indented continuation lines, and those lines.
+	let current: { item: PlanListItem; continuation: string[] } | undefined;
+
+	/** Fold the collected continuation into the item, then close it. */
+	const finish = (): void => {
+		if (current === undefined) return;
+		if (current.continuation.length > 0) {
+			current.item.step = parseStep(`${current.item.raw} ${current.continuation.join(" ")}`);
+		}
+		current = undefined;
+	};
 
 	plan.split("\n").forEach((line, index) => {
 		const fenceMatch = line.match(FENCE);
 		if (fenceMatch) {
+			finish();
 			if (fence === undefined) fence = fenceMatch[1][0];
 			else if (fence === fenceMatch[1][0]) fence = undefined;
 			return;
 		}
 		if (fence !== undefined) return;
 
+		if (line.trim() === "") {
+			finish();
+			return;
+		}
+
 		const match = line.match(LIST_ITEM);
-		if (!match) return;
-		const step = parseStep(match[3]);
-		if (!step.content) return;
-		items.push({ line: index, indent: match[1].length, lead: match[2], raw: match[3], step });
+		if (match) {
+			finish();
+			const step = parseStep(match[3]);
+			if (!step.content) return;
+			const item: PlanListItem = { line: index, indent: match[1].length, lead: match[2], raw: match[3], step };
+			items.push(item);
+			current = { item, continuation: [] };
+			return;
+		}
+
+		// A deeper, marker-less line continues the step's paragraph; a heading,
+		// a shallow line, or a blank line ends it. `raw` stays the first line so
+		// `setStepStatuses` edits the checkbox without touching these lines.
+		if (current !== undefined && indentOf(line) > current.item.indent && !HEADING.test(line)) {
+			const text = line.trim();
+			if (text) current.continuation.push(text);
+			return;
+		}
+
+		finish();
 	});
+
+	finish();
 	return items;
 }
 
@@ -208,7 +232,7 @@ function stepsSection(plan: string): { start: number; end: number } | undefined
 		if (!heading) continue;
 		const depth = heading[1].length;
 		if (start < 0) {
-			if (plainText(heading[2]).toLowerCase() !== "steps") continue;
+			if (normalizeHeadingText(heading[2]).toLowerCase() !== "steps") continue;
 			start = index;
 			level = depth;
 			continue;
@@ -281,7 +305,7 @@ export function verificationItem(plan: string): PlanStep | undefined {
 		// A fenced block is how the outline asks for commands; its fence lines are
 		// punctuation, not a check, so only the commands inside it are carried.
 		.filter((line) => !FENCE.test(line))
-		.map((line) => plainText(line.replace(LIST_PREFIX, "")))
+		.map((line) => cleanLabel(line.replace(LIST_PREFIX, "")))
 		.filter(Boolean);
 	if (items.length === 0) return undefined;
 	return { content: elide(`Verify: ${items.join("; ")}`), status: "pending" };
@@ -361,43 +385,6 @@ export function setStepStatuses(plan: string, updates: readonly StepEdit[]): str
 	return lines.join("\n");
 }
 
-/**
- * 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 extractPlanSections(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: plainText(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;
-}
-
 /**
  * The plan's own objective: the first paragraph of its `## Goal` section, with
  * inline markdown and a leading list marker removed.

package/extensions/plan/tools/enter.ts

@@ -12,8 +12,8 @@ import { GLYPHS } from "../../../lib/tui/glyphs.ts";
 import { paint } from "../../../lib/tui/tokens.ts";
 import { callLine, detailsOrLine } from "../../../lib/tui/tool.ts";
 import { failedResult } from "../../../lib/tool-result.ts";
-import { isRemoteTurn } from "../../../lib/interaction.ts";
-import { PLAN_CONSENT, READ_ONLY_SUMMARY } from "../../../lib/plan-entry.ts";
+import { isRemoteTurn, remoteLanguage } from "../../../lib/interaction.ts";
+import { PLAN_CONSENT, PLAN_CONSENT_SHORT, PLAN_CONSENT_SHORT_ZH, READ_ONLY_SUMMARY } from "../../../lib/plan-entry.ts";
 import { ENTER_TOOL, type PlanRuntime } from "../runtime.ts";
 import type { EnterPlanModeDetails } from "../types.ts";
 
@@ -53,7 +53,12 @@ export function registerEnterTool(pi: ExtensionAPI, runtime: PlanRuntime): void
 				);
 			}
 
-			const approved = await ctx.ui.confirm("Enter plan mode?", PLAN_CONSENT);
+			const consent = isRemoteTurn(ctx)
+				? remoteLanguage(ctx) === "zh"
+					? PLAN_CONSENT_SHORT_ZH
+					: PLAN_CONSENT_SHORT
+				: PLAN_CONSENT;
+			const approved = await ctx.ui.confirm("Enter plan mode?", consent);
 			if (!approved) {
 				return {
 					content: [{ type: "text", text: "Stayed in normal mode. Proceed, or ask the user how to continue." }],