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

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

@@ -21,7 +21,6 @@
  * This module owns paths and bytes only; tool wiring lives in `tools.ts`.
  */
 
-import { randomBytes } from "node:crypto";
 import {
 	existsSync,
 	lstatSync,
@@ -38,9 +37,9 @@ import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { CONFIG_DIR_NAME, getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { resolveEffectiveCwd } from "../../lib/env.ts";
+import { keepRevision, writeAtomic } from "./plan-files.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 {
@@ -63,6 +69,11 @@ export interface StoredPlan {
 /** A plan written to disk, carrying the title that named it. */
 export interface WrittenPlan extends StoredPlan {
 	title: string;
+	/**
+	 * The revision this write replaced, when it refined an existing plan: the text as the
+	 * reviewer last read it, kept beside the plan.
+	 */
+	replaced?: { path: string; relativePath: string };
 }
 
 /** One row of the plan index: enough to choose a plan without opening it. */
@@ -94,13 +105,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>;
@@ -196,27 +200,6 @@ function resolvePlanArg(dir: string, planPath: string): string {
 	return isAbsolute(text) ? resolve(text) : resolve(dir, text);
 }
 
-/**
- * Write a plan atomically: a hidden sibling temp file, then a rename. A crash
- * or a full disk mid-write leaves the previous file intact instead of a
- * truncated plan, and the temp name is a dotfile, so neither `latest()` nor a
- * plan lookup ever mistakes it for a plan.
- */
-function writeAtomic(path: string, content: string): void {
-	const temp = join(dirname(path), `.${basename(path)}.${randomBytes(6).toString("hex")}.tmp`);
-	try {
-		writeFileSync(temp, content, { encoding: "utf-8", flag: "wx" });
-		renameSync(temp, path);
-	} catch (error) {
-		try {
-			unlinkSync(temp);
-		} catch {
-			// The temp file was never created, or the rename already moved it.
-		}
-		throw error;
-	}
-}
-
 function uniquePath(dir: string, base: string): string {
 	const taken = (candidate: string): boolean => {
 		try {
@@ -330,8 +313,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();
@@ -370,8 +351,20 @@ export function createPlanStore(pi: ExtensionAPI, options: { now?: () => Date }
 			throw new Error(`The plan is too large with its review comments (${nextBytes} bytes).`);
 		}
 
+		// Both are kept: the plan is what the review and the model read from now on, and the
+		// revision is what they read before this call — the only thing a diff, or a comment
+		// carried onto a block that moved, can be answered against.
+		// A refinement that changed nothing has nothing to keep: the copy would be the plan.
+		const replaced = previous === undefined || previous === content ? undefined : keepRevision(path, previous);
 		writeAtomic(path, content);
-		return { path, relativePath: shortenPath(path), title, content, bytes: nextBytes };
+		return {
+			path,
+			relativePath: shortenPath(path),
+			title,
+			content,
+			bytes: nextBytes,
+			...(replaced === undefined ? {} : { replaced: { path: replaced, relativePath: shortenPath(replaced) } }),
+		};
 	};
 
 	const read = async (cwd: string, planPath: string): Promise<StoredPlan | undefined> => {
@@ -556,5 +549,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 };
 }

package/extensions/plan/policy.ts

@@ -14,36 +14,49 @@
  */
 
 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,
+	BOARD_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,
 ];
 
 /**
- * Tools that may stay active while planning. `subagent` is here so it is not
- * filtered out, but it is not in {@link PLAN_SAFE_TOOLS}: the `tool_call` guard
- * forces it read-only before the path backstop would see it. `powershell` is
- * deliberately absent — it is default-denied like any other shell.
+ * Tools that may stay active while planning. Two of them are here so they are not
+ * filtered out, without being in {@link PLAN_SAFE_TOOLS}: the `tool_call` guard
+ * narrows each before the path backstop would see it. `subagent` is forced
+ * read-only per call, and `board` admits only its `list` action — a model planning
+ * work should be able to read the board it is about to add cards to, and the hint
+ * cannot say that because the same tool writes. `powershell` is deliberately
+ * absent — it is default-denied like any other shell.
+ */
+export const PLAN_ALLOWED_TOOLS = [...PLAN_SAFE_TOOLS, SUBAGENT_TOOL, BOARD_TOOL];
+/**
+ * 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".
  */
-export const PLAN_ALLOWED_TOOLS = [...PLAN_SAFE_TOOLS, SUBAGENT_TOOL];
-/** Tools always blocked while planning, even when annotated read-only. */
 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.
  */
 
@@ -28,7 +28,7 @@ import { GLYPHS, STATUS_KEYS } from "../../lib/tui/glyphs.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import { createPlanStore, type PlanStore } from "./plans.ts";
 import { sameSections, sectionDigests, type SectionDigest } from "./plan-text.ts";
-import type { PlanModeEntry, ReviewBaselineEntry } from "./types.ts";
+import type { PlanModeEntry, ReviewBaselineEntry, SeededStepsEntry } from "./types.ts";
 
 /** Tool the model calls to leave plan mode after approval. */
 export const EXIT_TOOL = "exit_plan_mode";
@@ -44,13 +44,23 @@ export const SET_PLAN_STEPS_TOOL = "set_plan_steps";
 export const STATE_TYPE = PLAN_MODE_ENTRY_TYPE;
 /** Custom-entry type used for a plan's review baseline. */
 export const BASELINE_TYPE = "plan-baseline";
+/** Custom-entry type used for the steps one approval seeded, so a re-approval can replace them. */
+export const SEEDED_TYPE = "plan-seeded";
 
 /** 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 +71,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. */
@@ -71,12 +81,18 @@ export interface PlanRuntime {
 	reviewed(path: string): SectionDigest[] | undefined;
 	/** Remember what a review just showed, as a session entry on this branch. */
 	markReviewed(path: string, content: string): void;
+	/** The step texts the last approval of this plan appended, or undefined. */
+	seeded(path: string): string[] | undefined;
+	/** Record what this approval appended, so a re-approval can replace it. */
+	markSeeded(path: string, steps: readonly string[]): void;
 }
 
 /** What the branch carries: the last plan-mode state, and a baseline per plan. */
 interface BranchState {
 	mode: PlanModeEntry | undefined;
 	baselines: Map<string, SectionDigest[]>;
+	/** The step texts each approval appended, per plan path. */
+	seeded: Map<string, string[]>;
 }
 
 /** Well-formed `{ title, digest }` pairs from untrusted branch data, or undefined. */
@@ -98,6 +114,7 @@ function readSections(value: unknown): SectionDigest[] | undefined {
 function readBranchState(ctx: ExtensionContext): BranchState {
 	let mode: PlanModeEntry | undefined;
 	const baselines = new Map<string, SectionDigest[]>();
+	const seeded = new Map<string, string[]>();
 	for (const raw of ctx.sessionManager.getBranch()) {
 		const entry = raw as { type?: string; customType?: string; data?: unknown };
 		if (entry.type !== "custom") continue;
@@ -111,6 +128,16 @@ function readBranchState(ctx: ExtensionContext): BranchState {
 			mode = removed ? { enabled: data.enabled, removed } : { enabled: data.enabled };
 			continue;
 		}
+		if (entry.customType === SEEDED_TYPE) {
+			const data = entry.data as { path?: unknown; steps?: unknown } | null | undefined;
+			if (typeof data?.path !== "string" || !Array.isArray(data.steps)) continue;
+			// Branch data is untrusted: keep only the strings a step can be.
+			seeded.set(
+				resolve(data.path),
+				data.steps.filter((text): text is string => typeof text === "string"),
+			);
+			continue;
+		}
 		if (entry.customType !== BASELINE_TYPE) continue;
 		const data = entry.data as { path?: unknown; sections?: unknown } | null | undefined;
 		if (typeof data?.path !== "string") continue;
@@ -120,7 +147,7 @@ function readBranchState(ctx: ExtensionContext): BranchState {
 		// still answers a lookup for the plan it names.
 		if (sections) baselines.set(resolve(data.path), sections);
 	}
-	return { mode, baselines };
+	return { mode, baselines, seeded };
 }
 
 /** Compare two paths, resolving symlinks when possible so `/tmp` and `/private/tmp` match. */
@@ -153,17 +180,23 @@ export function createPlanRuntime(
 	// can mark what changed. Persisted with the branch, so `/resume` and `/tree`
 	// compare against the review this branch actually showed.
 	const reviewedPlans = new Map<string, SectionDigest[]>();
+	/** The steps each approval appended, so the next approval can replace its own leftovers. */
+	const seededPlans = new Map<string, string[]>();
 	// Tools plan mode deactivated, so disabling restores exactly those and does
 	// not re-activate a tool another extension intentionally hid.
 	let removedForPlan: string[] = [];
 
 	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);
 	};
 
@@ -224,6 +257,8 @@ export function createPlanRuntime(
 			// never showed has no digest here, so nothing looks changed until it does.
 			reviewedPlans.clear();
 			for (const [path, sections] of branch.baselines) reviewedPlans.set(path, sections);
+			seededPlans.clear();
+			for (const [path, steps] of branch.seeded) seededPlans.set(path, steps);
 			const persisted = branch.mode;
 			// `--plan` starts a fresh session in plan mode; an explicit persisted
 			// choice (including a later disable) wins over the launch flag.
@@ -241,13 +276,19 @@ export function createPlanRuntime(
 			if (ctx) setStatus(ctx);
 		},
 		plans,
-		isControlTool,
+		isOwnTool,
 		lastPlanPath: () => lastPlanPath,
 		setLastPlan: (ctx, path) => {
 			lastPlanPath = path;
 			setStatus(ctx);
 		},
 		reviewed: (path) => reviewedPlans.get(resolve(path)),
+		seeded: (path) => seededPlans.get(resolve(path)),
+		markSeeded: (path, steps) => {
+			const key = resolve(path);
+			seededPlans.set(key, [...steps]);
+			pi.appendEntry(SEEDED_TYPE, { path: key, steps: [...steps] } satisfies SeededStepsEntry);
+		},
 		markReviewed: (path, content) => {
 			const key = resolve(path);
 			const sections = sectionDigests(content);